# This is a BitKeeper generated patch for the following project: # Project Name: Linux kernel tree # This patch format is intended for GNU patch command version 2.5 or higher. # This patch includes the following deltas: # ChangeSet 1.1131 -> 1.1132 # arch/ppc64/kernel/signal.c 1.27 -> 1.28 # include/asm-ppc64/page.h 1.19 -> 1.20 # include/asm-ppc64/unistd.h 1.21 -> 1.22 # arch/ppc64/kernel/entry.S 1.26 -> 1.27 # arch/ppc64/kernel/udbg.c 1.8 -> 1.9 # include/asm-ppc64/processor.h 1.29 -> 1.30 # include/asm-ppc64/module.h 1.3 -> 1.4 # include/asm-ppc64/ucontext.h 1.3 -> 1.4 # arch/ppc64/kernel/chrp_setup.c 1.27 -> 1.28 # arch/ppc64/kernel/rtas.c 1.11 -> 1.12 # include/asm-ppc64/sigcontext.h 1.4 -> 1.5 # arch/ppc64/kernel/LparData.c 1.9 -> 1.10 # include/asm-ppc64/types.h 1.3 -> 1.4 # arch/ppc64/kernel/ras.c 1.4 -> 1.5 # include/asm-ppc64/proc_fs.h 1.2 -> 1.3 # arch/ppc64/kernel/irq.c 1.25 -> 1.26 # arch/ppc64/kernel/rtas-proc.c 1.6 -> 1.7 # arch/ppc64/kernel/setup.c 1.24 -> 1.25 # include/asm-ppc64/naca.h 1.6 -> 1.7 # arch/ppc64/kernel/traps.c 1.16 -> 1.17 # arch/ppc64/kernel/head.S 1.31 -> 1.32 # include/asm-ppc64/xics.h 1.5 -> 1.6 # arch/ppc64/kernel/xics.c 1.22 -> 1.23 # arch/ppc64/mm/init.c 1.42 -> 1.43 # arch/ppc64/kernel/open_pic.c 1.13 -> 1.14 # arch/ppc64/kernel/htab.c 1.33 -> 1.34 # arch/ppc64/kernel/process.c 1.31 -> 1.32 # arch/ppc64/kernel/pci_dma.c 1.14 -> 1.15 # arch/ppc64/kernel/open_pic_defs.h 1.2 -> 1.3 # arch/ppc64/kernel/asm-offsets.c 1.13 -> 1.14 # include/asm-ppc64/mmu.h 1.7 -> 1.8 # arch/ppc64/mm/numa.c 1.4 -> 1.5 # arch/ppc64/kernel/syscalls.c 1.10 -> 1.11 # include/asm-ppc64/ptrace.h 1.2 -> 1.3 # arch/ppc64/kernel/sys_ppc32.c 1.59 -> 1.60 # arch/ppc64/kernel/prom.c 1.25 -> 1.26 # arch/ppc64/kernel/iSeries_setup.c 1.12 -> 1.13 # arch/ppc64/kernel/smp.c 1.34 -> 1.35 # arch/ppc64/mm/fault.c 1.10 -> 1.11 # arch/ppc64/kernel/pacaData.c 1.6 -> 1.7 # arch/ppc64/kernel/pci.c 1.30 -> 1.31 # arch/ppc64/xmon/xmon.c 1.26 -> 1.27 # arch/ppc64/kernel/misc.S 1.57 -> 1.58 # arch/ppc64/kernel/signal32.c 1.39 -> 1.40 # arch/ppc64/kernel/rtas_flash.c 1.5 -> 1.6 # include/asm-ppc64/pgtable.h 1.22 -> 1.23 # include/asm-ppc64/mmzone.h 1.10 -> 1.11 # include/asm-ppc64/io.h 1.8 -> 1.9 # include/asm-ppc64/topology.h 1.7 -> 1.8 # arch/ppc64/kernel/module.c 1.4 -> 1.5 # arch/ppc64/kernel/Makefile 1.23 -> 1.24 # include/asm-ppc64/rtas.h 1.6 -> 1.7 # arch/ppc64/kernel/align.c 1.8 -> 1.9 # arch/ppc64/kernel/ioctl32.c 1.30 -> 1.31 # arch/ppc64/kernel/pSeries_lpar.c 1.21 -> 1.22 # # The following is the BitKeeper ChangeSet Log # -------------------------------------------- # 03/06/10 peter@chubb.wattle.id.au 1.1079.1.74 # [PATCH] ia64: Include lib/Kconfig for HPSIM # # I found the attached patch necessary to allow compressed file # systems to be used under the simulator. lib/Kconfig is needed to # configure in the zlib routines. # -------------------------------------------- # 03/06/10 peter@chubb.wattle.id.au 1.1079.1.75 # [PATCH] ia64: Define ia64_max_iommu_merge_mask unconditionally # # Define ia64_max_iommu_merge_mask even without CONFIG_PCI, # so that the simulator can link. # -------------------------------------------- # 03/06/10 davidm@tiger.hpl.hp.com 1.1132 # Fix gratuitous PPC64 changes (were probably caused by a bad bk merge # with Linus' tree). # -------------------------------------------- # diff -Nru a/arch/ppc64/kernel/LparData.c b/arch/ppc64/kernel/LparData.c --- a/arch/ppc64/kernel/LparData.c Fri Jun 13 00:37:27 2003 +++ b/arch/ppc64/kernel/LparData.c Fri Jun 13 00:37:27 2003 @@ -61,7 +61,7 @@ 0xc8a5d9c4, /* desc = "HvRD" ebcdic */ sizeof(struct HvReleaseData), offsetof(struct naca_struct, xItVpdAreas), - (struct naca_struct *)(NACA_VIRT_ADDR), /* 64-bit Naca address */ + (struct naca_struct *)(KERNELBASE+0x4000), /* 64-bit Naca address */ 0x6000, /* offset of LparMap within loadarea (see head.S) */ 0, 1, /* tags inactive */ diff -Nru a/arch/ppc64/kernel/Makefile b/arch/ppc64/kernel/Makefile --- a/arch/ppc64/kernel/Makefile Fri Jun 13 00:37:27 2003 +++ b/arch/ppc64/kernel/Makefile Fri Jun 13 00:37:27 2003 @@ -15,7 +15,7 @@ iSeries_IoMmTable.o iSeries_irq.o \ iSeries_VpdInfo.o XmPciLpEvent.o \ HvCall.o HvLpConfig.o LparData.o mf_proc.o \ - iSeries_setup.o ItLpQueue.o hvCall.o \ + proc_pmc.o iSeries_setup.o ItLpQueue.o hvCall.o \ mf.o HvLpEvent.o iSeries_proc.o obj-$(CONFIG_PPC_PSERIES) += pSeries_pci.o pSeries_lpar.o pSeries_hvCall.o \ @@ -25,7 +25,6 @@ obj-y += open_pic.o xics.o pSeries_htab.o rtas.o \ chrp_setup.o i8259.o ras.o prom.o -obj-$(CONFIG_PROC_FS) += proc_ppc64.o obj-$(CONFIG_RTAS_FLASH) += rtas_flash.o obj-$(CONFIG_SMP) += smp.o obj-$(CONFIG_MODULES) += module.o ppc_ksyms.o diff -Nru a/arch/ppc64/kernel/align.c b/arch/ppc64/kernel/align.c --- a/arch/ppc64/kernel/align.c Fri Jun 13 00:37:27 2003 +++ b/arch/ppc64/kernel/align.c Fri Jun 13 00:37:27 2003 @@ -237,7 +237,7 @@ dsisr = regs->dsisr; /* Power4 doesn't set DSISR for an alignment interrupt */ - if (!cpu_alignexc_sets_dsisr()) { + if (__is_processor(PV_POWER4) || __is_processor(PV_POWER4p)) { unsigned int real_instr; if (__get_user(real_instr, (unsigned int *)regs->nip)) return 0; @@ -309,7 +309,6 @@ /* Doing stfs, have to convert to single */ enable_kernel_fp(); cvt_df(¤t->thread.fpr[reg], (float *)&data.v[4], ¤t->thread.fpscr); - disable_kernel_fp(); } else data.dd = current->thread.fpr[reg]; @@ -343,7 +342,6 @@ /* Doing lfs, have to convert to double */ enable_kernel_fp(); cvt_fd((float *)&data.v[4], ¤t->thread.fpr[reg], ¤t->thread.fpscr); - disable_kernel_fp(); } else current->thread.fpr[reg] = data.dd; diff -Nru a/arch/ppc64/kernel/asm-offsets.c b/arch/ppc64/kernel/asm-offsets.c --- a/arch/ppc64/kernel/asm-offsets.c Fri Jun 13 00:37:27 2003 +++ b/arch/ppc64/kernel/asm-offsets.c Fri Jun 13 00:37:27 2003 @@ -59,14 +59,14 @@ /* naca */ DEFINE(PACA, offsetof(struct naca_struct, paca)); - DEFINE(DCACHEL1LINESIZE, offsetof(struct systemcfg, dCacheL1LineSize)); + DEFINE(DCACHEL1LINESIZE, offsetof(struct naca_struct, dCacheL1LineSize)); DEFINE(DCACHEL1LOGLINESIZE, offsetof(struct naca_struct, dCacheL1LogLineSize)); DEFINE(DCACHEL1LINESPERPAGE, offsetof(struct naca_struct, dCacheL1LinesPerPage)); - DEFINE(ICACHEL1LINESIZE, offsetof(struct systemcfg, iCacheL1LineSize)); + DEFINE(ICACHEL1LINESIZE, offsetof(struct naca_struct, iCacheL1LineSize)); DEFINE(ICACHEL1LOGLINESIZE, offsetof(struct naca_struct, iCacheL1LogLineSize)); DEFINE(ICACHEL1LINESPERPAGE, offsetof(struct naca_struct, iCacheL1LinesPerPage)); DEFINE(SLBSIZE, offsetof(struct naca_struct, slb_size)); - DEFINE(PLATFORM, offsetof(struct systemcfg, platform)); + DEFINE(PLATFORM, offsetof(struct naca_struct, platform)); /* paca */ DEFINE(PACA_SIZE, sizeof(struct paca_struct)); diff -Nru a/arch/ppc64/kernel/chrp_setup.c b/arch/ppc64/kernel/chrp_setup.c --- a/arch/ppc64/kernel/chrp_setup.c Fri Jun 13 00:37:27 2003 +++ b/arch/ppc64/kernel/chrp_setup.c Fri Jun 13 00:37:27 2003 @@ -263,8 +263,6 @@ char *os; static int display_character, set_indicator; static int max_width; - static spinlock_t progress_lock = SPIN_LOCK_UNLOCKED; - static int pending_newline = 0; /* did last write end with unprinted newline? */ if (!rtas.base) return; @@ -280,79 +278,34 @@ display_character = rtas_token("display-character"); set_indicator = rtas_token("set-indicator"); } - - if(display_character == RTAS_UNKNOWN_SERVICE) { - /* use hex display if available */ - if(set_indicator != RTAS_UNKNOWN_SERVICE) - rtas_call(set_indicator, 3, 1, NULL, 6, 0, hex); + if (display_character == RTAS_UNKNOWN_SERVICE) { + /* use hex display */ + if (set_indicator == RTAS_UNKNOWN_SERVICE) + return; + rtas_call(set_indicator, 3, 1, NULL, 6, 0, hex); return; } - spin_lock(&progress_lock); + rtas_call(display_character, 1, 1, NULL, '\r'); - /* Last write ended with newline, but we didn't print it since - * it would just clear the bottom line of output. Print it now - * instead. - * - * If no newline is pending, print a CR to start output at the - * beginning of the line. - */ - if(pending_newline) { - rtas_call(display_character, 1, 1, NULL, '\r'); - rtas_call(display_character, 1, 1, NULL, '\n'); - pending_newline = 0; - } else - rtas_call(display_character, 1, 1, NULL, '\r'); - width = max_width; os = s; - while (*os) { - if(*os == '\n' || *os == '\r') { - /* Blank to end of line. */ - while(width-- > 0) - rtas_call(display_character, 1, 1, NULL, ' '); - - /* If newline is the last character, save it - * until next call to avoid bumping up the - * display output. - */ - if(*os == '\n' && !os[1]) { - pending_newline = 1; - spin_unlock(&progress_lock); - return; - } - - /* RTAS wants CR-LF, not just LF */ - - if(*os == '\n') { - rtas_call(display_character, 1, 1, NULL, '\r'); - rtas_call(display_character, 1, 1, NULL, '\n'); - } else { - /* CR might be used to re-draw a line, so we'll - * leave it alone and not add LF. - */ - rtas_call(display_character, 1, 1, NULL, *os); - } - + while ( *os ) + { + if ( (*os == '\n') || (*os == '\r') ) width = max_width; - } else { + else width--; - rtas_call(display_character, 1, 1, NULL, *os); - } - - os++; - + rtas_call(display_character, 1, 1, NULL, *os++ ); /* if we overwrite the screen length */ - if ( width <= 0 ) + if ( width == 0 ) while ( (*os != 0) && (*os != '\n') && (*os != '\r') ) os++; } - + /* Blank to end of line. */ while ( width-- > 0 ) rtas_call(display_character, 1, 1, NULL, ' ' ); - - spin_unlock(&progress_lock); } extern void setup_default_decr(void); diff -Nru a/arch/ppc64/kernel/entry.S b/arch/ppc64/kernel/entry.S --- a/arch/ppc64/kernel/entry.S Fri Jun 13 00:37:27 2003 +++ b/arch/ppc64/kernel/entry.S Fri Jun 13 00:37:27 2003 @@ -225,6 +225,10 @@ bl .sys32_rt_sigreturn b 80f +_GLOBAL(ppc64_sigreturn) + bl .sys_sigreturn + b 80f + _GLOBAL(ppc64_rt_sigreturn) bl .sys_rt_sigreturn @@ -408,6 +412,11 @@ ld r4,GPR4(r1) ld r1,GPR1(r1) + /* + * What if we took an exception and stole this segment, we may + * fault on the above addresses and globber SRR0/1. Should check RI + * bit and repeat - Anton + */ rfid /* Note: this must change if we start using the TIF_NOTIFY_RESUME bit */ diff -Nru a/arch/ppc64/kernel/head.S b/arch/ppc64/kernel/head.S --- a/arch/ppc64/kernel/head.S Fri Jun 13 00:37:27 2003 +++ b/arch/ppc64/kernel/head.S Fri Jun 13 00:37:27 2003 @@ -29,8 +29,6 @@ #include #include #include -#include -#include #include #include #include @@ -51,9 +49,8 @@ * 0x0100 - 0x2fff : pSeries Interrupt prologs * 0x3000 - 0x3fff : Interrupt support * 0x4000 - 0x4fff : NACA - * 0x5000 - 0x5fff : SystemCfg + * 0x5000 - 0x5fff : Initial segment table * 0x6000 : iSeries and common interrupt prologs - * 0x9000 - 0x9fff : Initial segment table */ /* @@ -126,10 +123,6 @@ * All of it must fit below the first exception vector at 0x100. */ _GLOBAL(__secondary_hold) - mfmsr r24 - ori r24,r24,MSR_RI - mtmsrd r24 /* RI on */ - /* Grab our linux cpu number */ mr r24,r3 @@ -369,11 +362,11 @@ STD_EXCEPTION_PSERIES( 0x1300, InstructionBreakpoint ) /* Space for the naca. Architected to be located at real address - * NACA_PHYS_ADDR. Various tools rely on this location being fixed. + * 0x4000. Various tools rely on this location being fixed. * The first dword of the naca is required by iSeries LPAR to * point to itVpdAreas. On pSeries native, this value is not used. */ - . = NACA_PHYS_ADDR + . = 0x4000 .globl __end_interrupts .globl __start_naca __end_interrupts: @@ -387,14 +380,21 @@ .llong 0x0 .llong paca - . = SYSTEMCFG_PHYS_ADDR + /* + * Space for the initial segment table + * For LPAR, the hypervisor must fill in at least one entry + * before we get control (with relocate on) + */ + . = 0x5000 .globl __end_naca - .globl __start_systemcfg + .globl __start_stab __end_naca: -__start_systemcfg: - . = (SYSTEMCFG_PHYS_ADDR + PAGE_SIZE) - .globl __end_systemcfg -__end_systemcfg: +__start_stab: + + + . = 0x6000 + .globl __end_stab +__end_stab: #ifdef CONFIG_PPC_ISERIES /* @@ -408,7 +408,7 @@ .llong 1 /* # ESIDs to be mapped by hypervisor */ .llong 1 /* # memory ranges to be mapped by hypervisor */ - .llong STAB0_PAGE /* Page # of segment table within load area */ + .llong 5 /* Page # of segment table within load area */ .llong 0 /* Reserved */ .llong 0 /* Reserved */ .llong 0 /* Reserved */ @@ -529,20 +529,6 @@ MachineCheck_FWNMI: EXCEPTION_PROLOG_PSERIES(0x200, MachineCheck_common) - /* - * Space for the initial segment table - * For LPAR, the hypervisor must fill in at least one entry - * before we get control (with relocate on) - */ - . = STAB0_PHYS_ADDR - .globl __start_stab -__start_stab: - - . = (STAB0_PHYS_ADDR + PAGE_SIZE) - .globl __end_stab -__end_stab: - - /*** Common interrupt handlers ***/ STD_EXCEPTION_COMMON( 0x100, SystemReset, .SystemResetException ) @@ -796,16 +782,11 @@ FPUnavailable_common: EXCEPTION_PROLOG_COMMON bne .load_up_fpu /* if from user, just load it up */ - addi r3,r1,STACK_FRAME_OVERHEAD -#ifdef DO_SOFT_DISABLE - ld r20,SOFTE(r1) -#else - rldicl r20,r23,49,63 /* copy EE bit from saved MSR */ -#endif + li r20,0 li r6,0x800 - bl .save_remaining_regs - bl .KernelFPUnavailableException - BUG_OPCODE + bl .save_remaining_regs /* if from kernel, take a trap */ + bl .KernelFP + b .ret_from_except .globl SystemCall_common SystemCall_common: @@ -1051,7 +1032,7 @@ slbmfee r23,r22 rldicl r23,r23,37,63 cmpwi r23,0 - beq 4f /* Found an invalid entry */ + beq 3f /* Found an invalid entry */ addi r22,r22,1 cmpldi r22,64 @@ -1060,37 +1041,18 @@ /* No free entry - just take the next entry, round-robin */ /* XXX we should get the number of SLB entries from the naca */ SLB_NUM_ENTRIES = 64 -2: mfspr r21,SPRG3 + mfspr r21,SPRG3 ld r22,PACASTABRR(r21) addi r23,r22,1 cmpdi r23,SLB_NUM_ENTRIES - blt 3f + blt 2f li r23,1 -3: std r23,PACASTABRR(r21) +2: std r23,PACASTABRR(r21) /* r20 = vsid, r22 = entry */ - - /* - * Never cast out the segment for our kernel stack. Since we - * dont invalidate the ERAT we could have a valid translation - * for the kernel stack during the first part of exception exit - * which gets invalidated due to a tlbie from another cpu at a - * non recoverable point (after setting srr0/1) - Anton - */ - slbmfee r23,r22 - srdi r23,r23,28 - /* - * This is incorrect (r1 is not the kernel stack) if we entered - * from userspace but there is no critical window from userspace - * so this should be OK. Also if we cast out the userspace stack - * segment while in userspace we will fault it straight back in. - */ - srdi r21,r1,28 - cmpd r21,r23 - beq- 2b - +3: /* Put together the vsid portion of the entry. */ -4: li r21,0 + li r21,0 rldimi r21,r20,12,0 ori r20,r21,1024 ori r20,r20,128 /* set class bit for kernel region */ @@ -1098,6 +1060,17 @@ ori r20,r20,256 /* map kernel region with large ptes */ #endif + /* + * XXX we should handle this in the exception exit path in 2.5, + * we need to make this path quick - Anton + */ + /* Invalidate the old entry */ + slbmfee r21,r22 + lis r23,-2049 + ori r23,r23,65535 + and r21,r21,r23 + slbie r21 + /* Put together the esid portion of the entry. */ mfspr r21,DAR /* Get the new esid */ rldicl r21,r21,36,28 /* Permits a full 36b of ESID */ @@ -1279,12 +1252,9 @@ addi r2,r2,0x4000 addi r2,r2,0x4000 - LOADADDR(r9,systemcfg) - SET_REG_TO_CONST(r4, SYSTEMCFG_VIRT_ADDR) - std r4,0(r9) /* set the systemcfg pointer */ - LOADADDR(r9,naca) - SET_REG_TO_CONST(r4, NACA_VIRT_ADDR) + SET_REG_TO_CONST(r4, KERNELBASE) + addi r4,r4,0x4000 std r4,0(r9) /* set the naca pointer */ /* Get the pointer to the segment table */ @@ -1315,18 +1285,13 @@ /* Relocate the TOC from a virt addr to a real addr */ sub r2,r2,r3 - /* setup the systemcfg pointer which is needed by prom_init */ - LOADADDR(r9,systemcfg) - sub r9,r9,r3 /* addr of the variable systemcfg */ - SET_REG_TO_CONST(r4, SYSTEMCFG_VIRT_ADDR) - sub r4,r4,r3 - std r4,0(r9) /* set the value of systemcfg */ - /* setup the naca pointer which is needed by prom_init */ LOADADDR(r9,naca) sub r9,r9,r3 /* addr of the variable naca */ - SET_REG_TO_CONST(r4, NACA_VIRT_ADDR) + + SET_REG_TO_CONST(r4, KERNELBASE) sub r4,r4,r3 + addi r4,r4,0x4000 std r4,0(r9) /* set the value of naca */ /* DRENG / PPPBBB Fix the following comment!!! -Peter */ @@ -1445,13 +1410,11 @@ copy_to_here: /* - * load_up_fpu(unused, unused, tsk) * Disable FP for the task which had the FPU previously, * and save its floating-point registers in its thread_struct. * Enables the FPU for use in the kernel on return. * On SMP we know the fpu is free, since we give it up every - * switch (ie, no lazy save of the FP registers). - * On entry: r13 == 'current' && last_task_used_math != 'current' + * switch. -- Cort */ _STATIC(load_up_fpu) mfmsr r5 /* grab the current MSR */ @@ -1469,30 +1432,27 @@ ld r4,last_task_used_math@l(r3) cmpi 0,r4,0 beq 1f - /* Save FP state to last_task_used_math's THREAD struct */ - addi r4,r4,THREAD + addi r4,r4,THREAD /* want THREAD of last_task_used_math */ SAVE_32FPRS(0, r4) mffs fr0 stfd fr0,THREAD_FPSCR(r4) - /* Disable FP for last_task_used_math */ ld r5,PT_REGS(r4) ld r4,_MSR-STACK_FRAME_OVERHEAD(r5) li r20,MSR_FP|MSR_FE0|MSR_FE1 - andc r4,r4,r20 + andc r4,r4,r20 /* disable FP for previous task */ std r4,_MSR-STACK_FRAME_OVERHEAD(r5) 1: #endif /* CONFIG_SMP */ /* enable use of FP after return */ ld r4,PACACURRENT(r13) addi r5,r4,THREAD /* Get THREAD */ - ld r4,THREAD_FPEXC_MODE(r5) + lwz r4,THREAD_FPEXC_MODE(r5) ori r23,r23,MSR_FP or r23,r23,r4 lfd fr0,THREAD_FPSCR(r5) mtfsf 0xff,fr0 REST_32FPRS(0, r5) #ifndef CONFIG_SMP - /* Update last_task_used_math to 'current' */ subi r4,r5,THREAD /* Back to 'current' */ std r4,last_task_used_math@l(r3) #endif /* CONFIG_SMP */ @@ -1500,16 +1460,19 @@ b fast_exception_return /* - * disable_kernel_fp() - * Disable the FPU. + * FP unavailable trap from kernel - print a message, but let + * the task use FP in the kernel until it returns to user mode. */ -_GLOBAL(disable_kernel_fp) - mfmsr r3 - rldicl r0,r3,(63-MSR_FP_LG),1 - rldicl r3,r0,(MSR_FP_LG+1),0 - mtmsrd r3 /* disable use of fpu now */ - isync - blr +_GLOBAL(KernelFP) + ld r3,_MSR(r1) + ori r3,r3,MSR_FP + std r3,_MSR(r1) /* enable use of FP after return */ + LOADADDR(r3,86f) + ld r4,PACACURRENT(r13) /* current */ + ld r5,_NIP(r1) + b .ret_from_except +86: .string "floating point used in kernel (task=%p, pc=%x)\n" + .align 4 /* * giveup_fpu(tsk) @@ -1599,8 +1562,8 @@ sc /* HvCall_setASR */ #else /* set the ASR */ - li r3,SYSTEMCFG_PHYS_ADDR /* r3 = ptr to systemcfg */ - lwz r3,PLATFORM(r3) /* r3 = platform flags */ + addi r3,0,0x4000 /* r3 = ptr to naca */ + lhz r3,PLATFORM(r3) /* r3 = platform flags */ cmpldi r3,PLATFORM_PSERIES_LPAR bne 98f mfspr r3,PVR @@ -1679,20 +1642,10 @@ bl .reloc_offset mr r26,r3 - mfmsr r6 - ori r6,r6,MSR_RI - mtmsrd r6 /* RI on */ - - /* setup the systemcfg pointer which is needed by *tab_initialize */ - LOADADDR(r6,systemcfg) - sub r6,r6,r26 /* addr of the variable systemcfg */ - li r27,SYSTEMCFG_PHYS_ADDR - std r27,0(r6) /* set the value of systemcfg */ - /* setup the naca pointer which is needed by *tab_initialize */ LOADADDR(r6,naca) sub r6,r6,r26 /* addr of the variable naca */ - li r27,NACA_PHYS_ADDR + li r27,0x4000 std r27,0(r6) /* set the value of naca */ #ifdef CONFIG_HMT @@ -1756,12 +1709,15 @@ sub r13,r13,r26 /* convert to physical addr */ mtspr SPRG3,r13 /* PPPBBB: Temp... -Peter */ - ld r3,PACASTABREAL(r13) + li r3,0x5000 + std r3,PACASTABREAL(r13) + LOADADDR(r24, __start_stab) + std r24,PACASTABVIRT(r13) ori r4,r3,1 /* turn on valid bit */ /* set the ASR */ - li r3,SYSTEMCFG_PHYS_ADDR /* r3 = ptr to systemcfg */ - lwz r3,PLATFORM(r3) /* r3 = platform flags */ + addi r3,0,0x4000 /* r3 = ptr to naca */ + lhz r3,PLATFORM(r3) /* r3 = platform flags */ cmpldi r3,PLATFORM_PSERIES_LPAR bne 98f mfspr r3,PVR @@ -1785,8 +1741,8 @@ bl .stab_initialize bl .htab_initialize - li r3,SYSTEMCFG_PHYS_ADDR /* r3 = ptr to systemcfg */ - lwz r3,PLATFORM(r3) /* r3 = platform flags */ + addi r3,0,0x4000 /* r3 = ptr to naca */ + lhz r3,PLATFORM(r3) /* r3 = platform flags */ cmpldi r3,PLATFORM_PSERIES bne 98f LOADADDR(r6,_SDR1) /* Only if NOT LPAR */ @@ -1835,14 +1791,11 @@ addi r2,r2,0x4000 addi r2,r2,0x4000 - /* setup the systemcfg pointer */ - LOADADDR(r9,systemcfg) - SET_REG_TO_CONST(r8, SYSTEMCFG_VIRT_ADDR) - std r8,0(r9) - - /* setup the naca pointer */ + /* setup the naca pointer */ LOADADDR(r9,naca) - SET_REG_TO_CONST(r8, NACA_VIRT_ADDR) + + SET_REG_TO_CONST(r8, KERNELBASE) + addi r8,r8,0x4000 std r8,0(r9) /* set the value of the naca ptr */ LOADADDR(r26, boot_cpuid) @@ -1993,7 +1946,7 @@ hardware_int_paca0: .space 8*4096 -/* 1 page segment table per cpu (max 48, cpu0 allocated at STAB0_PHYS_ADDR) */ +/* 1 page segment table per cpu (max 48) */ .globl stab_array stab_array: .space 4096 * 48 diff -Nru a/arch/ppc64/kernel/htab.c b/arch/ppc64/kernel/htab.c --- a/arch/ppc64/kernel/htab.c Fri Jun 13 00:37:27 2003 +++ b/arch/ppc64/kernel/htab.c Fri Jun 13 00:37:27 2003 @@ -101,7 +101,7 @@ hpteg = ((hash & htab_data.htab_hash_mask)*HPTES_PER_GROUP); - if (systemcfg->platform == PLATFORM_PSERIES_LPAR) + if (naca->platform == PLATFORM_PSERIES_LPAR) ret = pSeries_lpar_hpte_insert(hpteg, va, (unsigned long)__v2a(addr) >> PAGE_SHIFT, 0, mode, 1, large); @@ -140,7 +140,7 @@ htab_data.htab_num_ptegs = pteg_count; htab_data.htab_hash_mask = pteg_count - 1; - if (systemcfg->platform == PLATFORM_PSERIES) { + if (naca->platform == PLATFORM_PSERIES) { /* Find storage for the HPT. Must be contiguous in * the absolute address space. */ @@ -165,15 +165,15 @@ mode_rw = _PAGE_ACCESSED | _PAGE_COHERENT | PP_RWXX; /* XXX we currently map kernel text rw, should fix this */ - if (cpu_has_largepage() && systemcfg->physicalMemorySize > 256*MB) { + if (cpu_has_largepage() && naca->physicalMemorySize > 256*MB) { create_pte_mapping((unsigned long)KERNELBASE, KERNELBASE + 256*MB, mode_rw, 0); create_pte_mapping((unsigned long)KERNELBASE + 256*MB, - KERNELBASE + (systemcfg->physicalMemorySize), + KERNELBASE + (naca->physicalMemorySize), mode_rw, 1); } else { create_pte_mapping((unsigned long)KERNELBASE, - KERNELBASE+(systemcfg->physicalMemorySize), + KERNELBASE+(naca->physicalMemorySize), mode_rw, 0); } } diff -Nru a/arch/ppc64/kernel/iSeries_setup.c b/arch/ppc64/kernel/iSeries_setup.c --- a/arch/ppc64/kernel/iSeries_setup.c Fri Jun 13 00:37:27 2003 +++ b/arch/ppc64/kernel/iSeries_setup.c Fri Jun 13 00:37:27 2003 @@ -561,13 +561,13 @@ * which should be equal to * nextPhysChunk */ - systemcfg->physicalMemorySize = chunk_to_addr(nextPhysChunk); + naca->physicalMemorySize = chunk_to_addr(nextPhysChunk); /* Bolt kernel mappings for all of memory */ - iSeries_bolt_kernel( 0, systemcfg->physicalMemorySize ); + iSeries_bolt_kernel( 0, naca->physicalMemorySize ); lmb_init(); - lmb_add( 0, systemcfg->physicalMemorySize ); + lmb_add( 0, naca->physicalMemorySize ); lmb_analyze(); /* ?? */ lmb_reserve( 0, __pa(klimit)); @@ -584,28 +584,29 @@ static void __init setup_iSeries_cache_sizes(void) { - unsigned int i, n; - unsigned int procIx = get_paca()->xLpPaca.xDynHvPhysicalProcIndex; - - systemcfg->iCacheL1Size = xIoHriProcessorVpd[procIx].xInstCacheSize * 1024; - systemcfg->iCacheL1LineSize = xIoHriProcessorVpd[procIx].xInstCacheOperandSize; - systemcfg->dCacheL1Size = xIoHriProcessorVpd[procIx].xDataL1CacheSizeKB * 1024; - systemcfg->dCacheL1LineSize = xIoHriProcessorVpd[procIx].xDataCacheOperandSize; - naca->iCacheL1LinesPerPage = PAGE_SIZE / systemcfg->iCacheL1LineSize; - naca->dCacheL1LinesPerPage = PAGE_SIZE / systemcfg->dCacheL1LineSize; + unsigned i,n; + unsigned procIx = get_paca()->xLpPaca.xDynHvPhysicalProcIndex; - i = systemcfg->iCacheL1LineSize; + naca->iCacheL1LineSize = xIoHriProcessorVpd[procIx].xInstCacheOperandSize; + naca->dCacheL1LineSize = xIoHriProcessorVpd[procIx].xDataCacheOperandSize; + naca->iCacheL1LinesPerPage = PAGE_SIZE / naca->iCacheL1LineSize; + naca->dCacheL1LinesPerPage = PAGE_SIZE / naca->dCacheL1LineSize; + i = naca->iCacheL1LineSize; n = 0; while ((i=(i/2))) ++n; naca->iCacheL1LogLineSize = n; - - i = systemcfg->dCacheL1LineSize; + i = naca->dCacheL1LineSize; n = 0; while ((i=(i/2))) ++n; naca->dCacheL1LogLineSize = n; - printk( "D-cache line size = %d\n", (unsigned int)systemcfg->dCacheL1LineSize); - printk( "I-cache line size = %d\n", (unsigned int)systemcfg->iCacheL1LineSize); + printk( "D-cache line size = %d (log = %d)\n", + (unsigned)naca->dCacheL1LineSize, + (unsigned)naca->dCacheL1LogLineSize ); + printk( "I-cache line size = %d (log = %d)\n", + (unsigned)naca->iCacheL1LineSize, + (unsigned)naca->iCacheL1LogLineSize ); + } /* @@ -647,11 +648,6 @@ void * eventStack; unsigned procIx = get_paca()->xLpPaca.xDynHvPhysicalProcIndex; - /* Add an eye catcher and the systemcfg layout version number */ - strcpy(systemcfg->eye_catcher, "SYSTEMCFG:PPC64"); - systemcfg->version.major = SYSTEMCFG_MAJOR; - systemcfg->version.minor = SYSTEMCFG_MINOR; - /* Setup the Lp Event Queue */ /* Allocate a page for the Event Stack @@ -700,8 +696,8 @@ printk("Time base frequency = %lu.%02lu\n", tbFreqMhz, tbFreqMhzHundreths ); - systemcfg->processor = xIoHriProcessorVpd[procIx].xPVR; - printk("Processor version = %x\n", systemcfg->processor); + printk("Processor version = %x\n", + xIoHriProcessorVpd[procIx].xPVR ); } @@ -730,9 +726,9 @@ seq_printf(m,"time base\t: %lu.%02luMHz\n", tbFreqMhz, tbFreqMhzHundreths ); seq_printf(m,"i-cache\t\t: %d\n", - systemcfg->iCacheL1LineSize); + naca->iCacheL1LineSize); seq_printf(m,"d-cache\t\t: %d\n", - systemcfg->dCacheL1LineSize); + naca->dCacheL1LineSize); } diff -Nru a/arch/ppc64/kernel/ioctl32.c b/arch/ppc64/kernel/ioctl32.c --- a/arch/ppc64/kernel/ioctl32.c Fri Jun 13 00:37:27 2003 +++ b/arch/ppc64/kernel/ioctl32.c Fri Jun 13 00:37:27 2003 @@ -23,7 +23,6 @@ #include #include #include -#include #include #include #include @@ -51,7 +50,6 @@ #include #include #include -#include #include #include #include @@ -579,17 +577,6 @@ len += sizeof(struct ethtool_regs); break; } - case ETHTOOL_GEEPROM: - case ETHTOOL_SEEPROM: { - struct ethtool_eeprom *promaddr = (struct ethtool_eeprom *)A(data); - /* darned variable size arguments */ - if (get_user(len, (u32 *)&promaddr->len)) { - err = -EFAULT; - goto out; - } - len += sizeof(struct ethtool_eeprom); - break; - } case ETHTOOL_GSET: case ETHTOOL_SSET: len = sizeof(struct ethtool_cmd); break; default: @@ -672,47 +659,6 @@ return err; } -static inline void *alloc_user_space(long len) -{ - struct pt_regs *regs = current->thread.regs; - unsigned long usp = regs->gpr[1]; - - /* - * We cant access below the stack pointer in the 32bit ABI and - * can access 288 bytes in the 64bit ABI - */ - if (!(test_thread_flag(TIF_32BIT))) - usp -= 288; - - return (void *) (usp - len); -} - -int siocdevprivate_ioctl(unsigned int fd, unsigned int cmd, unsigned long arg) -{ - struct ifreq *u_ifreq64; - struct ifreq32 *u_ifreq32 = (struct ifreq32 *) arg; - char tmp_buf[IFNAMSIZ]; - void __user *data64; - u32 data32; - - if (copy_from_user(&tmp_buf[0], &(u_ifreq32->ifr_ifrn.ifrn_name[0]), - IFNAMSIZ)) - return -EFAULT; - if (__get_user(data32, &u_ifreq32->ifr_ifru.ifru_data)) - return -EFAULT; - data64 = A(data32); - - u_ifreq64 = alloc_user_space(sizeof(*u_ifreq64)); - - /* Don't check these user accesses, just let that get trapped - * in the ioctl handler instead. - */ - copy_to_user(&u_ifreq64->ifr_ifrn.ifrn_name[0], &tmp_buf[0], IFNAMSIZ); - __put_user(data64, &u_ifreq64->ifr_ifru.ifru_data); - - return sys_ioctl(fd, cmd, (unsigned long) u_ifreq64); -} - static int dev_ifsioc(unsigned int fd, unsigned int cmd, unsigned long arg) { struct ifreq ifr; @@ -3697,32 +3643,670 @@ #define BNEPGETCONNLIST _IOR('B', 210, int) #define BNEPGETCONNINFO _IOR('B', 211, int) -#define HANDLE_IOCTL(cmd,handler) { cmd, (ioctl_trans_handler_t)handler, 0 }, -#define COMPATIBLE_IOCTL(cmd) HANDLE_IOCTL(cmd,sys_ioctl) +struct ioctl_trans { + unsigned long cmd; + unsigned long handler; + unsigned long next; +}; + +#define COMPATIBLE_IOCTL(cmd) { cmd, (unsigned long)sys_ioctl, 0 }, -#define IOCTL_TABLE_START \ - struct ioctl_trans ioctl_start[] = { -#define IOCTL_TABLE_END \ - }; struct ioctl_trans ioctl_end[0]; +#define HANDLE_IOCTL(cmd,handler) { cmd, (unsigned long)handler, 0 }, #define AUTOFS_IOC_SETTIMEOUT32 _IOWR(0x93,0x64,unsigned int) #define SMB_IOC_GETMOUNTUID_32 _IOR('u', 1, compat_uid_t) -IOCTL_TABLE_START -#include +static struct ioctl_trans ioctl_translations[] = { + /* List here explicitly which ioctl's need translation, + * all others default to calling sys_ioctl(). + */ +/* Big T */ +COMPATIBLE_IOCTL(TCGETA) +COMPATIBLE_IOCTL(TCSETA) +COMPATIBLE_IOCTL(TCSETAW) +COMPATIBLE_IOCTL(TCSETAF) +COMPATIBLE_IOCTL(TCSBRK) COMPATIBLE_IOCTL(TCSBRKP) +COMPATIBLE_IOCTL(TCXONC) +COMPATIBLE_IOCTL(TCFLSH) +COMPATIBLE_IOCTL(TCGETS) +COMPATIBLE_IOCTL(TCSETS) +COMPATIBLE_IOCTL(TCSETSW) +COMPATIBLE_IOCTL(TCSETSF) +COMPATIBLE_IOCTL(TIOCLINUX) COMPATIBLE_IOCTL(TIOCSTART) COMPATIBLE_IOCTL(TIOCSTOP) +/* Little t */ +COMPATIBLE_IOCTL(TIOCGETD) +COMPATIBLE_IOCTL(TIOCSETD) +COMPATIBLE_IOCTL(TIOCEXCL) +COMPATIBLE_IOCTL(TIOCNXCL) +COMPATIBLE_IOCTL(TIOCCONS) +COMPATIBLE_IOCTL(TIOCGSOFTCAR) +COMPATIBLE_IOCTL(TIOCSSOFTCAR) +COMPATIBLE_IOCTL(TIOCSWINSZ) +COMPATIBLE_IOCTL(TIOCGWINSZ) +COMPATIBLE_IOCTL(TIOCMGET) +COMPATIBLE_IOCTL(TIOCMBIC) +COMPATIBLE_IOCTL(TIOCMBIS) +COMPATIBLE_IOCTL(TIOCMSET) +COMPATIBLE_IOCTL(TIOCPKT) +COMPATIBLE_IOCTL(TIOCNOTTY) +COMPATIBLE_IOCTL(TIOCSTI) +COMPATIBLE_IOCTL(TIOCOUTQ) +COMPATIBLE_IOCTL(TIOCSPGRP) +COMPATIBLE_IOCTL(TIOCGPGRP) +COMPATIBLE_IOCTL(TIOCSCTTY) +COMPATIBLE_IOCTL(TIOCGPTN) +COMPATIBLE_IOCTL(TIOCSPTLCK) COMPATIBLE_IOCTL(TIOCGSERIAL) COMPATIBLE_IOCTL(TIOCSSERIAL) +COMPATIBLE_IOCTL(TIOCSERGETLSR) COMPATIBLE_IOCTL(TIOCSLTC) +/* Big F */ +COMPATIBLE_IOCTL(FBIOGET_VSCREENINFO) +COMPATIBLE_IOCTL(FBIOPUT_VSCREENINFO) +COMPATIBLE_IOCTL(FBIOPAN_DISPLAY) +COMPATIBLE_IOCTL(FBIOGET_CON2FBMAP) +COMPATIBLE_IOCTL(FBIOPUT_CON2FBMAP) #if 0 COMPATIBLE_IOCTL(FBIOBLANK) #endif +/* Little f */ +COMPATIBLE_IOCTL(FIOCLEX) +COMPATIBLE_IOCTL(FIONCLEX) +COMPATIBLE_IOCTL(FIOASYNC) +COMPATIBLE_IOCTL(FIONBIO) +COMPATIBLE_IOCTL(FIONREAD) /* This is also TIOCINQ */ +/* 0x00 */ +COMPATIBLE_IOCTL(FIBMAP) +COMPATIBLE_IOCTL(FIGETBSZ) +/* 0x03 -- HD/IDE ioctl's used by hdparm and friends. + * Some need translations, these do not. + */ +COMPATIBLE_IOCTL(HDIO_GET_IDENTITY) +COMPATIBLE_IOCTL(HDIO_SET_DMA) +COMPATIBLE_IOCTL(HDIO_SET_UNMASKINTR) +COMPATIBLE_IOCTL(HDIO_SET_NOWERR) +COMPATIBLE_IOCTL(HDIO_SET_32BIT) +COMPATIBLE_IOCTL(HDIO_SET_MULTCOUNT) +COMPATIBLE_IOCTL(HDIO_DRIVE_CMD) +COMPATIBLE_IOCTL(HDIO_SET_PIO_MODE) +COMPATIBLE_IOCTL(HDIO_SET_NICE) +/* 0x02 -- Floppy ioctls */ +COMPATIBLE_IOCTL(FDMSGON) +COMPATIBLE_IOCTL(FDMSGOFF) +COMPATIBLE_IOCTL(FDSETEMSGTRESH) +COMPATIBLE_IOCTL(FDFLUSH) +COMPATIBLE_IOCTL(FDWERRORCLR) +COMPATIBLE_IOCTL(FDSETMAXERRS) +COMPATIBLE_IOCTL(FDGETMAXERRS) +COMPATIBLE_IOCTL(FDGETDRVTYP) +COMPATIBLE_IOCTL(FDEJECT) +COMPATIBLE_IOCTL(FDCLRPRM) +COMPATIBLE_IOCTL(FDFMTBEG) +COMPATIBLE_IOCTL(FDFMTEND) +COMPATIBLE_IOCTL(FDRESET) +COMPATIBLE_IOCTL(FDTWADDLE) +COMPATIBLE_IOCTL(FDFMTTRK) +COMPATIBLE_IOCTL(FDRAWCMD) +/* 0x12 */ +COMPATIBLE_IOCTL(BLKROSET) +COMPATIBLE_IOCTL(BLKROGET) +COMPATIBLE_IOCTL(BLKRRPART) +COMPATIBLE_IOCTL(BLKFLSBUF) +COMPATIBLE_IOCTL(BLKSECTSET) +COMPATIBLE_IOCTL(BLKSSZGET) +COMPATIBLE_IOCTL(BLKRASET) +COMPATIBLE_IOCTL(BLKFRASET) +/* RAID */ +COMPATIBLE_IOCTL(RAID_VERSION) +COMPATIBLE_IOCTL(GET_ARRAY_INFO) +COMPATIBLE_IOCTL(GET_DISK_INFO) +COMPATIBLE_IOCTL(PRINT_RAID_DEBUG) +COMPATIBLE_IOCTL(CLEAR_ARRAY) +COMPATIBLE_IOCTL(ADD_NEW_DISK) +COMPATIBLE_IOCTL(HOT_REMOVE_DISK) +COMPATIBLE_IOCTL(SET_ARRAY_INFO) +COMPATIBLE_IOCTL(SET_DISK_INFO) +COMPATIBLE_IOCTL(WRITE_RAID_INFO) +COMPATIBLE_IOCTL(UNPROTECT_ARRAY) +COMPATIBLE_IOCTL(PROTECT_ARRAY) +COMPATIBLE_IOCTL(HOT_ADD_DISK) +COMPATIBLE_IOCTL(SET_DISK_FAULTY) +COMPATIBLE_IOCTL(RUN_ARRAY) +COMPATIBLE_IOCTL(START_ARRAY) +COMPATIBLE_IOCTL(STOP_ARRAY) +COMPATIBLE_IOCTL(STOP_ARRAY_RO) +COMPATIBLE_IOCTL(RESTART_ARRAY_RW) +/* Big K */ +COMPATIBLE_IOCTL(PIO_FONT) +COMPATIBLE_IOCTL(GIO_FONT) +COMPATIBLE_IOCTL(KDSIGACCEPT) +COMPATIBLE_IOCTL(KDGETKEYCODE) +COMPATIBLE_IOCTL(KDSETKEYCODE) +COMPATIBLE_IOCTL(KIOCSOUND) +COMPATIBLE_IOCTL(KDMKTONE) +COMPATIBLE_IOCTL(KDGKBTYPE) +COMPATIBLE_IOCTL(KDSETMODE) +COMPATIBLE_IOCTL(KDGETMODE) +COMPATIBLE_IOCTL(KDSKBMODE) +COMPATIBLE_IOCTL(KDGKBMODE) +COMPATIBLE_IOCTL(KDSKBMETA) +COMPATIBLE_IOCTL(KDGKBMETA) +COMPATIBLE_IOCTL(KDGKBENT) +COMPATIBLE_IOCTL(KDSKBENT) +COMPATIBLE_IOCTL(KDGKBSENT) +COMPATIBLE_IOCTL(KDSKBSENT) +COMPATIBLE_IOCTL(KDGKBDIACR) +COMPATIBLE_IOCTL(KDKBDREP) +COMPATIBLE_IOCTL(KDSKBDIACR) +COMPATIBLE_IOCTL(KDGKBLED) +COMPATIBLE_IOCTL(KDSKBLED) +COMPATIBLE_IOCTL(KDGETLED) +COMPATIBLE_IOCTL(KDSETLED) +COMPATIBLE_IOCTL(GIO_SCRNMAP) +COMPATIBLE_IOCTL(PIO_SCRNMAP) +COMPATIBLE_IOCTL(GIO_UNISCRNMAP) +COMPATIBLE_IOCTL(PIO_UNISCRNMAP) +COMPATIBLE_IOCTL(PIO_FONTRESET) +COMPATIBLE_IOCTL(PIO_UNIMAPCLR) +/* Big S */ +COMPATIBLE_IOCTL(SCSI_IOCTL_GET_IDLUN) +COMPATIBLE_IOCTL(SCSI_IOCTL_PROBE_HOST) +COMPATIBLE_IOCTL(SCSI_IOCTL_GET_PCI) +COMPATIBLE_IOCTL(SCSI_IOCTL_DOORLOCK) +COMPATIBLE_IOCTL(SCSI_IOCTL_DOORUNLOCK) +COMPATIBLE_IOCTL(SCSI_IOCTL_TEST_UNIT_READY) +COMPATIBLE_IOCTL(SCSI_IOCTL_TAGGED_ENABLE) +COMPATIBLE_IOCTL(SCSI_IOCTL_TAGGED_DISABLE) +COMPATIBLE_IOCTL(SCSI_IOCTL_GET_BUS_NUMBER) +COMPATIBLE_IOCTL(SCSI_IOCTL_SEND_COMMAND) +/* Big T */ +COMPATIBLE_IOCTL(TUNSETNOCSUM) +COMPATIBLE_IOCTL(TUNSETDEBUG) +COMPATIBLE_IOCTL(TUNSETIFF) +COMPATIBLE_IOCTL(TUNSETPERSIST) +COMPATIBLE_IOCTL(TUNSETOWNER) +/* Big V */ +COMPATIBLE_IOCTL(VT_SETMODE) +COMPATIBLE_IOCTL(VT_GETMODE) +COMPATIBLE_IOCTL(VT_GETSTATE) +COMPATIBLE_IOCTL(VT_OPENQRY) +COMPATIBLE_IOCTL(VT_ACTIVATE) +COMPATIBLE_IOCTL(VT_WAITACTIVE) +COMPATIBLE_IOCTL(VT_RELDISP) +COMPATIBLE_IOCTL(VT_DISALLOCATE) +COMPATIBLE_IOCTL(VT_RESIZE) +COMPATIBLE_IOCTL(VT_RESIZEX) +COMPATIBLE_IOCTL(VT_LOCKSWITCH) +COMPATIBLE_IOCTL(VT_UNLOCKSWITCH) +/* Little v, the video4linux ioctls */ +COMPATIBLE_IOCTL(VIDIOCGCAP) +COMPATIBLE_IOCTL(VIDIOCGCHAN) +COMPATIBLE_IOCTL(VIDIOCSCHAN) +COMPATIBLE_IOCTL(VIDIOCGPICT) +COMPATIBLE_IOCTL(VIDIOCSPICT) +COMPATIBLE_IOCTL(VIDIOCCAPTURE) +COMPATIBLE_IOCTL(VIDIOCKEY) +COMPATIBLE_IOCTL(VIDIOCGAUDIO) +COMPATIBLE_IOCTL(VIDIOCSAUDIO) +COMPATIBLE_IOCTL(VIDIOCSYNC) +COMPATIBLE_IOCTL(VIDIOCMCAPTURE) +COMPATIBLE_IOCTL(VIDIOCGMBUF) +COMPATIBLE_IOCTL(VIDIOCGUNIT) +COMPATIBLE_IOCTL(VIDIOCGCAPTURE) +COMPATIBLE_IOCTL(VIDIOCSCAPTURE) +/* BTTV specific... */ +COMPATIBLE_IOCTL(_IOW('v', BASE_VIDIOCPRIVATE+0, char [256])) +COMPATIBLE_IOCTL(_IOR('v', BASE_VIDIOCPRIVATE+1, char [256])) +COMPATIBLE_IOCTL(_IOR('v' , BASE_VIDIOCPRIVATE+2, unsigned int)) +COMPATIBLE_IOCTL(_IOW('v' , BASE_VIDIOCPRIVATE+3, char [16])) /* struct bttv_pll_info */ +COMPATIBLE_IOCTL(_IOR('v' , BASE_VIDIOCPRIVATE+4, int)) +COMPATIBLE_IOCTL(_IOR('v' , BASE_VIDIOCPRIVATE+5, int)) +COMPATIBLE_IOCTL(_IOR('v' , BASE_VIDIOCPRIVATE+6, int)) +COMPATIBLE_IOCTL(_IOR('v' , BASE_VIDIOCPRIVATE+7, int)) /* Little p (/dev/rtc, /dev/envctrl, etc.) */ COMPATIBLE_IOCTL(_IOR('p', 20, int[7])) /* RTCGET */ COMPATIBLE_IOCTL(_IOW('p', 21, int[7])) /* RTCSET */ - +COMPATIBLE_IOCTL(RTC_AIE_ON) +COMPATIBLE_IOCTL(RTC_AIE_OFF) +COMPATIBLE_IOCTL(RTC_UIE_ON) +COMPATIBLE_IOCTL(RTC_UIE_OFF) +COMPATIBLE_IOCTL(RTC_PIE_ON) +COMPATIBLE_IOCTL(RTC_PIE_OFF) +COMPATIBLE_IOCTL(RTC_WIE_ON) +COMPATIBLE_IOCTL(RTC_WIE_OFF) +COMPATIBLE_IOCTL(RTC_ALM_SET) +COMPATIBLE_IOCTL(RTC_ALM_READ) +COMPATIBLE_IOCTL(RTC_RD_TIME) +COMPATIBLE_IOCTL(RTC_SET_TIME) +COMPATIBLE_IOCTL(RTC_WKALM_SET) +COMPATIBLE_IOCTL(RTC_WKALM_RD) +/* Little m */ +COMPATIBLE_IOCTL(MTIOCTOP) +/* Socket level stuff */ +COMPATIBLE_IOCTL(FIOSETOWN) +COMPATIBLE_IOCTL(SIOCSPGRP) +COMPATIBLE_IOCTL(FIOGETOWN) +COMPATIBLE_IOCTL(SIOCGPGRP) +COMPATIBLE_IOCTL(SIOCATMARK) +COMPATIBLE_IOCTL(SIOCSIFLINK) +COMPATIBLE_IOCTL(SIOCSIFENCAP) +COMPATIBLE_IOCTL(SIOCGIFENCAP) +COMPATIBLE_IOCTL(SIOCSIFBR) +COMPATIBLE_IOCTL(SIOCGIFBR) +COMPATIBLE_IOCTL(SIOCSARP) +COMPATIBLE_IOCTL(SIOCGARP) +COMPATIBLE_IOCTL(SIOCDARP) +COMPATIBLE_IOCTL(SIOCSRARP) +COMPATIBLE_IOCTL(SIOCGRARP) +COMPATIBLE_IOCTL(SIOCDRARP) +COMPATIBLE_IOCTL(SIOCADDDLCI) +COMPATIBLE_IOCTL(SIOCDELDLCI) +COMPATIBLE_IOCTL(SIOCGMIIPHY) +COMPATIBLE_IOCTL(SIOCGMIIREG) +COMPATIBLE_IOCTL(SIOCSMIIREG) +COMPATIBLE_IOCTL(SIOCGIFVLAN) +COMPATIBLE_IOCTL(SIOCSIFVLAN) +/* SG stuff */ +COMPATIBLE_IOCTL(SG_SET_TIMEOUT) +COMPATIBLE_IOCTL(SG_GET_TIMEOUT) +COMPATIBLE_IOCTL(SG_EMULATED_HOST) +COMPATIBLE_IOCTL(SG_SET_TRANSFORM) +COMPATIBLE_IOCTL(SG_GET_TRANSFORM) +COMPATIBLE_IOCTL(SG_SET_RESERVED_SIZE) +COMPATIBLE_IOCTL(SG_GET_RESERVED_SIZE) +COMPATIBLE_IOCTL(SG_GET_SCSI_ID) +COMPATIBLE_IOCTL(SG_SET_FORCE_LOW_DMA) +COMPATIBLE_IOCTL(SG_GET_LOW_DMA) +COMPATIBLE_IOCTL(SG_SET_FORCE_PACK_ID) +COMPATIBLE_IOCTL(SG_GET_PACK_ID) +COMPATIBLE_IOCTL(SG_GET_NUM_WAITING) +COMPATIBLE_IOCTL(SG_SET_DEBUG) +COMPATIBLE_IOCTL(SG_GET_SG_TABLESIZE) +COMPATIBLE_IOCTL(SG_GET_COMMAND_Q) +COMPATIBLE_IOCTL(SG_SET_COMMAND_Q) +COMPATIBLE_IOCTL(SG_GET_VERSION_NUM) +COMPATIBLE_IOCTL(SG_NEXT_CMD_LEN) +COMPATIBLE_IOCTL(SG_SCSI_RESET) +COMPATIBLE_IOCTL(SG_GET_REQUEST_TABLE) +COMPATIBLE_IOCTL(SG_SET_KEEP_ORPHAN) +COMPATIBLE_IOCTL(SG_GET_KEEP_ORPHAN) +/* PPP stuff */ +COMPATIBLE_IOCTL(PPPIOCGFLAGS) +COMPATIBLE_IOCTL(PPPIOCSFLAGS) +COMPATIBLE_IOCTL(PPPIOCGASYNCMAP) +COMPATIBLE_IOCTL(PPPIOCSASYNCMAP) +COMPATIBLE_IOCTL(PPPIOCGUNIT) +COMPATIBLE_IOCTL(PPPIOCGRASYNCMAP) +COMPATIBLE_IOCTL(PPPIOCSRASYNCMAP) +COMPATIBLE_IOCTL(PPPIOCGMRU) +COMPATIBLE_IOCTL(PPPIOCSMRU) +COMPATIBLE_IOCTL(PPPIOCSMAXCID) +COMPATIBLE_IOCTL(PPPIOCGXASYNCMAP) +COMPATIBLE_IOCTL(LPGETSTATUS) +COMPATIBLE_IOCTL(PPPIOCSXASYNCMAP) +COMPATIBLE_IOCTL(PPPIOCXFERUNIT) +COMPATIBLE_IOCTL(PPPIOCGNPMODE) +COMPATIBLE_IOCTL(PPPIOCSNPMODE) +COMPATIBLE_IOCTL(PPPIOCGDEBUG) +COMPATIBLE_IOCTL(PPPIOCSDEBUG) +COMPATIBLE_IOCTL(PPPIOCNEWUNIT) +COMPATIBLE_IOCTL(PPPIOCATTACH) +COMPATIBLE_IOCTL(PPPIOCDETACH) +COMPATIBLE_IOCTL(PPPIOCSMRRU) +COMPATIBLE_IOCTL(PPPIOCCONNECT) +COMPATIBLE_IOCTL(PPPIOCDISCONN) +COMPATIBLE_IOCTL(PPPIOCATTCHAN) +COMPATIBLE_IOCTL(PPPIOCGCHAN) +/* PPPOX */ +COMPATIBLE_IOCTL(PPPOEIOCSFWD) +COMPATIBLE_IOCTL(PPPOEIOCDFWD) +/* CDROM stuff */ +COMPATIBLE_IOCTL(CDROMPAUSE) +COMPATIBLE_IOCTL(CDROMRESUME) +COMPATIBLE_IOCTL(CDROMPLAYMSF) +COMPATIBLE_IOCTL(CDROMPLAYTRKIND) +COMPATIBLE_IOCTL(CDROMREADTOCHDR) +COMPATIBLE_IOCTL(CDROMREADTOCENTRY) +COMPATIBLE_IOCTL(CDROMSTOP) +COMPATIBLE_IOCTL(CDROMSTART) +COMPATIBLE_IOCTL(CDROMEJECT) +COMPATIBLE_IOCTL(CDROMVOLCTRL) +COMPATIBLE_IOCTL(CDROMSUBCHNL) +COMPATIBLE_IOCTL(CDROMEJECT_SW) +COMPATIBLE_IOCTL(CDROMMULTISESSION) +COMPATIBLE_IOCTL(CDROM_GET_MCN) +COMPATIBLE_IOCTL(CDROMRESET) +COMPATIBLE_IOCTL(CDROMVOLREAD) +COMPATIBLE_IOCTL(CDROMSEEK) +COMPATIBLE_IOCTL(CDROMPLAYBLK) +COMPATIBLE_IOCTL(CDROMCLOSETRAY) +COMPATIBLE_IOCTL(CDROM_SET_OPTIONS) +COMPATIBLE_IOCTL(CDROM_CLEAR_OPTIONS) +COMPATIBLE_IOCTL(CDROM_SELECT_SPEED) +COMPATIBLE_IOCTL(CDROM_SELECT_DISC) +COMPATIBLE_IOCTL(CDROM_MEDIA_CHANGED) +COMPATIBLE_IOCTL(CDROM_DRIVE_STATUS) +COMPATIBLE_IOCTL(CDROM_DISC_STATUS) +COMPATIBLE_IOCTL(CDROM_CHANGER_NSLOTS) +COMPATIBLE_IOCTL(CDROM_LOCKDOOR) +COMPATIBLE_IOCTL(CDROM_DEBUG) +COMPATIBLE_IOCTL(CDROM_GET_CAPABILITY) +/* DVD ioctls */ +COMPATIBLE_IOCTL(DVD_READ_STRUCT) +COMPATIBLE_IOCTL(DVD_WRITE_STRUCT) +COMPATIBLE_IOCTL(DVD_AUTH) +/* Big L */ +COMPATIBLE_IOCTL(LOOP_SET_FD) +COMPATIBLE_IOCTL(LOOP_CLR_FD) +/* Big Q for sound/OSS */ +COMPATIBLE_IOCTL(SNDCTL_SEQ_RESET) +COMPATIBLE_IOCTL(SNDCTL_SEQ_SYNC) +COMPATIBLE_IOCTL(SNDCTL_SYNTH_INFO) +COMPATIBLE_IOCTL(SNDCTL_SEQ_CTRLRATE) +COMPATIBLE_IOCTL(SNDCTL_SEQ_GETOUTCOUNT) +COMPATIBLE_IOCTL(SNDCTL_SEQ_GETINCOUNT) +COMPATIBLE_IOCTL(SNDCTL_SEQ_PERCMODE) +COMPATIBLE_IOCTL(SNDCTL_FM_LOAD_INSTR) +COMPATIBLE_IOCTL(SNDCTL_SEQ_TESTMIDI) +COMPATIBLE_IOCTL(SNDCTL_SEQ_RESETSAMPLES) +COMPATIBLE_IOCTL(SNDCTL_SEQ_NRSYNTHS) +COMPATIBLE_IOCTL(SNDCTL_SEQ_NRMIDIS) +COMPATIBLE_IOCTL(SNDCTL_MIDI_INFO) +COMPATIBLE_IOCTL(SNDCTL_SEQ_THRESHOLD) +COMPATIBLE_IOCTL(SNDCTL_SYNTH_MEMAVL) +COMPATIBLE_IOCTL(SNDCTL_FM_4OP_ENABLE) +COMPATIBLE_IOCTL(SNDCTL_SEQ_PANIC) +COMPATIBLE_IOCTL(SNDCTL_SEQ_OUTOFBAND) +COMPATIBLE_IOCTL(SNDCTL_SEQ_GETTIME) +COMPATIBLE_IOCTL(SNDCTL_SYNTH_ID) +COMPATIBLE_IOCTL(SNDCTL_SYNTH_CONTROL) +COMPATIBLE_IOCTL(SNDCTL_SYNTH_REMOVESAMPLE) +/* Big T for sound/OSS */ +COMPATIBLE_IOCTL(SNDCTL_TMR_TIMEBASE) +COMPATIBLE_IOCTL(SNDCTL_TMR_START) +COMPATIBLE_IOCTL(SNDCTL_TMR_STOP) +COMPATIBLE_IOCTL(SNDCTL_TMR_CONTINUE) +COMPATIBLE_IOCTL(SNDCTL_TMR_TEMPO) +COMPATIBLE_IOCTL(SNDCTL_TMR_SOURCE) +COMPATIBLE_IOCTL(SNDCTL_TMR_METRONOME) +COMPATIBLE_IOCTL(SNDCTL_TMR_SELECT) +/* Little m for sound/OSS */ +COMPATIBLE_IOCTL(SNDCTL_MIDI_PRETIME) +COMPATIBLE_IOCTL(SNDCTL_MIDI_MPUMODE) +COMPATIBLE_IOCTL(SNDCTL_MIDI_MPUCMD) +/* Big P for sound/OSS */ +COMPATIBLE_IOCTL(SNDCTL_DSP_RESET) +COMPATIBLE_IOCTL(SNDCTL_DSP_SYNC) +COMPATIBLE_IOCTL(SNDCTL_DSP_SPEED) +COMPATIBLE_IOCTL(SNDCTL_DSP_STEREO) +COMPATIBLE_IOCTL(SNDCTL_DSP_GETBLKSIZE) +COMPATIBLE_IOCTL(SNDCTL_DSP_CHANNELS) +COMPATIBLE_IOCTL(SOUND_PCM_WRITE_FILTER) +COMPATIBLE_IOCTL(SNDCTL_DSP_POST) +COMPATIBLE_IOCTL(SNDCTL_DSP_SUBDIVIDE) +COMPATIBLE_IOCTL(SNDCTL_DSP_SETFRAGMENT) +COMPATIBLE_IOCTL(SNDCTL_DSP_GETFMTS) +COMPATIBLE_IOCTL(SNDCTL_DSP_SETFMT) +COMPATIBLE_IOCTL(SNDCTL_DSP_GETOSPACE) +COMPATIBLE_IOCTL(SNDCTL_DSP_GETISPACE) +COMPATIBLE_IOCTL(SNDCTL_DSP_NONBLOCK) +COMPATIBLE_IOCTL(SNDCTL_DSP_GETCAPS) +COMPATIBLE_IOCTL(SNDCTL_DSP_GETTRIGGER) +COMPATIBLE_IOCTL(SNDCTL_DSP_SETTRIGGER) +COMPATIBLE_IOCTL(SNDCTL_DSP_GETIPTR) +COMPATIBLE_IOCTL(SNDCTL_DSP_GETOPTR) +/* SNDCTL_DSP_MAPINBUF, XXX needs translation */ +/* SNDCTL_DSP_MAPOUTBUF, XXX needs translation */ +COMPATIBLE_IOCTL(SNDCTL_DSP_SETSYNCRO) +COMPATIBLE_IOCTL(SNDCTL_DSP_SETDUPLEX) +COMPATIBLE_IOCTL(SNDCTL_DSP_GETODELAY) +COMPATIBLE_IOCTL(SNDCTL_DSP_PROFILE) +COMPATIBLE_IOCTL(SOUND_PCM_READ_RATE) +COMPATIBLE_IOCTL(SOUND_PCM_READ_CHANNELS) +COMPATIBLE_IOCTL(SOUND_PCM_READ_BITS) +COMPATIBLE_IOCTL(SOUND_PCM_READ_FILTER) +/* Big C for sound/OSS */ +COMPATIBLE_IOCTL(SNDCTL_COPR_RESET) +COMPATIBLE_IOCTL(SNDCTL_COPR_LOAD) +COMPATIBLE_IOCTL(SNDCTL_COPR_RDATA) +COMPATIBLE_IOCTL(SNDCTL_COPR_RCODE) +COMPATIBLE_IOCTL(SNDCTL_COPR_WDATA) +COMPATIBLE_IOCTL(SNDCTL_COPR_WCODE) +COMPATIBLE_IOCTL(SNDCTL_COPR_RUN) +COMPATIBLE_IOCTL(SNDCTL_COPR_HALT) +COMPATIBLE_IOCTL(SNDCTL_COPR_SENDMSG) +COMPATIBLE_IOCTL(SNDCTL_COPR_RCVMSG) +/* Big M for sound/OSS */ +COMPATIBLE_IOCTL(SOUND_MIXER_READ_VOLUME) +COMPATIBLE_IOCTL(SOUND_MIXER_READ_BASS) +COMPATIBLE_IOCTL(SOUND_MIXER_READ_TREBLE) +COMPATIBLE_IOCTL(SOUND_MIXER_READ_SYNTH) +COMPATIBLE_IOCTL(SOUND_MIXER_READ_PCM) +COMPATIBLE_IOCTL(SOUND_MIXER_READ_SPEAKER) +COMPATIBLE_IOCTL(SOUND_MIXER_READ_LINE) +COMPATIBLE_IOCTL(SOUND_MIXER_READ_MIC) +COMPATIBLE_IOCTL(SOUND_MIXER_READ_CD) +COMPATIBLE_IOCTL(SOUND_MIXER_READ_IMIX) +COMPATIBLE_IOCTL(SOUND_MIXER_READ_ALTPCM) +COMPATIBLE_IOCTL(SOUND_MIXER_READ_RECLEV) +COMPATIBLE_IOCTL(SOUND_MIXER_READ_IGAIN) +COMPATIBLE_IOCTL(SOUND_MIXER_READ_OGAIN) +COMPATIBLE_IOCTL(SOUND_MIXER_READ_LINE1) +COMPATIBLE_IOCTL(SOUND_MIXER_READ_LINE2) +COMPATIBLE_IOCTL(SOUND_MIXER_READ_LINE3) +COMPATIBLE_IOCTL(MIXER_READ(SOUND_MIXER_DIGITAL1)) +COMPATIBLE_IOCTL(MIXER_READ(SOUND_MIXER_DIGITAL2)) +COMPATIBLE_IOCTL(MIXER_READ(SOUND_MIXER_DIGITAL3)) +COMPATIBLE_IOCTL(MIXER_READ(SOUND_MIXER_PHONEIN)) +COMPATIBLE_IOCTL(MIXER_READ(SOUND_MIXER_PHONEOUT)) +COMPATIBLE_IOCTL(MIXER_READ(SOUND_MIXER_VIDEO)) +COMPATIBLE_IOCTL(MIXER_READ(SOUND_MIXER_RADIO)) +COMPATIBLE_IOCTL(MIXER_READ(SOUND_MIXER_MONITOR)) +COMPATIBLE_IOCTL(SOUND_MIXER_READ_MUTE) +/* SOUND_MIXER_READ_ENHANCE, same value as READ_MUTE */ +/* SOUND_MIXER_READ_LOUD, same value as READ_MUTE */ +COMPATIBLE_IOCTL(SOUND_MIXER_READ_RECSRC) +COMPATIBLE_IOCTL(SOUND_MIXER_READ_DEVMASK) +COMPATIBLE_IOCTL(SOUND_MIXER_READ_RECMASK) +COMPATIBLE_IOCTL(SOUND_MIXER_READ_STEREODEVS) +COMPATIBLE_IOCTL(SOUND_MIXER_READ_CAPS) +COMPATIBLE_IOCTL(SOUND_MIXER_WRITE_VOLUME) +COMPATIBLE_IOCTL(SOUND_MIXER_WRITE_BASS) +COMPATIBLE_IOCTL(SOUND_MIXER_WRITE_TREBLE) +COMPATIBLE_IOCTL(SOUND_MIXER_WRITE_SYNTH) +COMPATIBLE_IOCTL(SOUND_MIXER_WRITE_PCM) +COMPATIBLE_IOCTL(SOUND_MIXER_WRITE_SPEAKER) +COMPATIBLE_IOCTL(SOUND_MIXER_WRITE_LINE) +COMPATIBLE_IOCTL(SOUND_MIXER_WRITE_MIC) +COMPATIBLE_IOCTL(SOUND_MIXER_WRITE_CD) +COMPATIBLE_IOCTL(SOUND_MIXER_WRITE_IMIX) +COMPATIBLE_IOCTL(SOUND_MIXER_WRITE_ALTPCM) +COMPATIBLE_IOCTL(SOUND_MIXER_WRITE_RECLEV) +COMPATIBLE_IOCTL(SOUND_MIXER_WRITE_IGAIN) +COMPATIBLE_IOCTL(SOUND_MIXER_WRITE_OGAIN) +COMPATIBLE_IOCTL(SOUND_MIXER_WRITE_LINE1) +COMPATIBLE_IOCTL(SOUND_MIXER_WRITE_LINE2) +COMPATIBLE_IOCTL(SOUND_MIXER_WRITE_LINE3) +COMPATIBLE_IOCTL(MIXER_WRITE(SOUND_MIXER_DIGITAL1)) +COMPATIBLE_IOCTL(MIXER_WRITE(SOUND_MIXER_DIGITAL2)) +COMPATIBLE_IOCTL(MIXER_WRITE(SOUND_MIXER_DIGITAL3)) +COMPATIBLE_IOCTL(MIXER_WRITE(SOUND_MIXER_PHONEIN)) +COMPATIBLE_IOCTL(MIXER_WRITE(SOUND_MIXER_PHONEOUT)) +COMPATIBLE_IOCTL(MIXER_WRITE(SOUND_MIXER_VIDEO)) +COMPATIBLE_IOCTL(MIXER_WRITE(SOUND_MIXER_RADIO)) +COMPATIBLE_IOCTL(MIXER_WRITE(SOUND_MIXER_MONITOR)) +COMPATIBLE_IOCTL(SOUND_MIXER_WRITE_MUTE) +/* SOUND_MIXER_WRITE_ENHANCE, same value as WRITE_MUTE */ +/* SOUND_MIXER_WRITE_LOUD, same value as WRITE_MUTE */ +COMPATIBLE_IOCTL(SOUND_MIXER_WRITE_RECSRC) +COMPATIBLE_IOCTL(SOUND_MIXER_INFO) +COMPATIBLE_IOCTL(SOUND_OLD_MIXER_INFO) +COMPATIBLE_IOCTL(SOUND_MIXER_ACCESS) +COMPATIBLE_IOCTL(SOUND_MIXER_PRIVATE1) +COMPATIBLE_IOCTL(SOUND_MIXER_PRIVATE2) +COMPATIBLE_IOCTL(SOUND_MIXER_PRIVATE3) +COMPATIBLE_IOCTL(SOUND_MIXER_PRIVATE4) +COMPATIBLE_IOCTL(SOUND_MIXER_PRIVATE5) +COMPATIBLE_IOCTL(SOUND_MIXER_GETLEVELS) +COMPATIBLE_IOCTL(SOUND_MIXER_SETLEVELS) +COMPATIBLE_IOCTL(OSS_GETVERSION) +/* AUTOFS */ +COMPATIBLE_IOCTL(AUTOFS_IOC_READY) +COMPATIBLE_IOCTL(AUTOFS_IOC_FAIL) +COMPATIBLE_IOCTL(AUTOFS_IOC_CATATONIC) +COMPATIBLE_IOCTL(AUTOFS_IOC_PROTOVER) +COMPATIBLE_IOCTL(AUTOFS_IOC_EXPIRE) +/* DEVFS */ +COMPATIBLE_IOCTL(DEVFSDIOC_GET_PROTO_REV) +COMPATIBLE_IOCTL(DEVFSDIOC_SET_EVENT_MASK) +COMPATIBLE_IOCTL(DEVFSDIOC_RELEASE_EVENT_QUEUE) +COMPATIBLE_IOCTL(DEVFSDIOC_SET_DEBUG_MASK) +/* Raw devices */ +COMPATIBLE_IOCTL(RAW_SETBIND) +COMPATIBLE_IOCTL(RAW_GETBIND) +/* SMB ioctls which do not need any translations */ +COMPATIBLE_IOCTL(SMB_IOC_NEWCONN) +/* NCP ioctls which do not need any translations */ +COMPATIBLE_IOCTL(NCP_IOC_CONN_LOGGED_IN) +COMPATIBLE_IOCTL(NCP_IOC_SIGN_INIT) +COMPATIBLE_IOCTL(NCP_IOC_SIGN_WANTED) +COMPATIBLE_IOCTL(NCP_IOC_SET_SIGN_WANTED) +COMPATIBLE_IOCTL(NCP_IOC_LOCKUNLOCK) +COMPATIBLE_IOCTL(NCP_IOC_GETROOT) +COMPATIBLE_IOCTL(NCP_IOC_SETROOT) +COMPATIBLE_IOCTL(NCP_IOC_GETCHARSETS) +COMPATIBLE_IOCTL(NCP_IOC_SETCHARSETS) +COMPATIBLE_IOCTL(NCP_IOC_GETDENTRYTTL) +COMPATIBLE_IOCTL(NCP_IOC_SETDENTRYTTL) +/* Little a */ +COMPATIBLE_IOCTL(ATMSIGD_CTRL) +COMPATIBLE_IOCTL(ATMARPD_CTRL) +COMPATIBLE_IOCTL(ATMLEC_CTRL) +COMPATIBLE_IOCTL(ATMLEC_MCAST) +COMPATIBLE_IOCTL(ATMLEC_DATA) +COMPATIBLE_IOCTL(ATM_SETSC) +COMPATIBLE_IOCTL(SIOCSIFATMTCP) +COMPATIBLE_IOCTL(SIOCMKCLIP) +COMPATIBLE_IOCTL(ATMARP_MKIP) +COMPATIBLE_IOCTL(ATMARP_SETENTRY) +COMPATIBLE_IOCTL(ATMARP_ENCAP) +COMPATIBLE_IOCTL(ATMTCP_CREATE) +COMPATIBLE_IOCTL(ATMTCP_REMOVE) +COMPATIBLE_IOCTL(ATMMPC_CTRL) +COMPATIBLE_IOCTL(ATMMPC_DATA) +#if defined(CONFIG_DRM) || defined(CONFIG_DRM_MODULE) +COMPATIBLE_IOCTL(DRM_IOCTL_GET_MAGIC) +COMPATIBLE_IOCTL(DRM_IOCTL_IRQ_BUSID) +COMPATIBLE_IOCTL(DRM_IOCTL_AUTH_MAGIC) +COMPATIBLE_IOCTL(DRM_IOCTL_BLOCK) +COMPATIBLE_IOCTL(DRM_IOCTL_UNBLOCK) +COMPATIBLE_IOCTL(DRM_IOCTL_CONTROL) +COMPATIBLE_IOCTL(DRM_IOCTL_ADD_BUFS) +COMPATIBLE_IOCTL(DRM_IOCTL_MARK_BUFS) +COMPATIBLE_IOCTL(DRM_IOCTL_ADD_CTX) +COMPATIBLE_IOCTL(DRM_IOCTL_RM_CTX) +COMPATIBLE_IOCTL(DRM_IOCTL_MOD_CTX) +COMPATIBLE_IOCTL(DRM_IOCTL_GET_CTX) +COMPATIBLE_IOCTL(DRM_IOCTL_SWITCH_CTX) +COMPATIBLE_IOCTL(DRM_IOCTL_NEW_CTX) +COMPATIBLE_IOCTL(DRM_IOCTL_ADD_DRAW) +COMPATIBLE_IOCTL(DRM_IOCTL_RM_DRAW) +COMPATIBLE_IOCTL(DRM_IOCTL_LOCK) +COMPATIBLE_IOCTL(DRM_IOCTL_UNLOCK) +COMPATIBLE_IOCTL(DRM_IOCTL_FINISH) +#endif /* DRM */ +/* Big W */ +/* WIOC_GETSUPPORT not yet implemented -E */ +COMPATIBLE_IOCTL(WDIOC_GETSTATUS) +COMPATIBLE_IOCTL(WDIOC_GETBOOTSTATUS) +COMPATIBLE_IOCTL(WDIOC_GETTEMP) +COMPATIBLE_IOCTL(WDIOC_SETOPTIONS) +COMPATIBLE_IOCTL(WDIOC_KEEPALIVE) +/* Big R */ +COMPATIBLE_IOCTL(RNDGETENTCNT) +COMPATIBLE_IOCTL(RNDADDTOENTCNT) +COMPATIBLE_IOCTL(RNDGETPOOL) +COMPATIBLE_IOCTL(RNDADDENTROPY) +COMPATIBLE_IOCTL(RNDZAPENTCNT) +COMPATIBLE_IOCTL(RNDCLEARPOOL) +/* Bluetooth ioctls */ +COMPATIBLE_IOCTL(HCIDEVUP) +COMPATIBLE_IOCTL(HCIDEVDOWN) +COMPATIBLE_IOCTL(HCIDEVRESET) +COMPATIBLE_IOCTL(HCIDEVRESTAT) +COMPATIBLE_IOCTL(HCIGETDEVLIST) +COMPATIBLE_IOCTL(HCIGETDEVINFO) +COMPATIBLE_IOCTL(HCIGETCONNLIST) +COMPATIBLE_IOCTL(HCIGETCONNINFO) +COMPATIBLE_IOCTL(HCISETRAW) +COMPATIBLE_IOCTL(HCISETSCAN) +COMPATIBLE_IOCTL(HCISETAUTH) +COMPATIBLE_IOCTL(HCISETENCRYPT) +COMPATIBLE_IOCTL(HCISETPTYPE) +COMPATIBLE_IOCTL(HCISETLINKPOL) +COMPATIBLE_IOCTL(HCISETLINKMODE) +COMPATIBLE_IOCTL(HCISETACLMTU) +COMPATIBLE_IOCTL(HCISETSCOMTU) +COMPATIBLE_IOCTL(HCIINQUIRY) +COMPATIBLE_IOCTL(HCIUARTSETPROTO) +COMPATIBLE_IOCTL(HCIUARTGETPROTO) +COMPATIBLE_IOCTL(RFCOMMCREATEDEV) +COMPATIBLE_IOCTL(RFCOMMRELEASEDEV) +COMPATIBLE_IOCTL(RFCOMMGETDEVLIST) +COMPATIBLE_IOCTL(RFCOMMGETDEVINFO) +COMPATIBLE_IOCTL(RFCOMMSTEALDLC) +COMPATIBLE_IOCTL(BNEPCONNADD) +COMPATIBLE_IOCTL(BNEPCONNDEL) +COMPATIBLE_IOCTL(BNEPGETCONNLIST) +COMPATIBLE_IOCTL(BNEPGETCONNINFO) +COMPATIBLE_IOCTL(PCIIOC_CONTROLLER) +COMPATIBLE_IOCTL(PCIIOC_MMAP_IS_IO) +COMPATIBLE_IOCTL(PCIIOC_MMAP_IS_MEM) +COMPATIBLE_IOCTL(PCIIOC_WRITE_COMBINE) +/* USB */ +COMPATIBLE_IOCTL(USBDEVFS_RESETEP) +COMPATIBLE_IOCTL(USBDEVFS_SETINTERFACE) +COMPATIBLE_IOCTL(USBDEVFS_SETCONFIGURATION) +COMPATIBLE_IOCTL(USBDEVFS_GETDRIVER) +COMPATIBLE_IOCTL(USBDEVFS_DISCARDURB) +COMPATIBLE_IOCTL(USBDEVFS_CLAIMINTERFACE) +COMPATIBLE_IOCTL(USBDEVFS_RELEASEINTERFACE) +COMPATIBLE_IOCTL(USBDEVFS_CONNECTINFO) +COMPATIBLE_IOCTL(USBDEVFS_HUB_PORTINFO) +COMPATIBLE_IOCTL(USBDEVFS_RESET) +COMPATIBLE_IOCTL(USBDEVFS_CLEAR_HALT) +/* MTD */ +COMPATIBLE_IOCTL(MEMGETINFO) +COMPATIBLE_IOCTL(MEMERASE) +COMPATIBLE_IOCTL(MEMLOCK) +COMPATIBLE_IOCTL(MEMUNLOCK) +COMPATIBLE_IOCTL(MEMGETREGIONCOUNT) +COMPATIBLE_IOCTL(MEMGETREGIONINFO) +/* NBD */ +COMPATIBLE_IOCTL(NBD_SET_SOCK) +COMPATIBLE_IOCTL(NBD_SET_BLKSIZE) +COMPATIBLE_IOCTL(NBD_SET_SIZE) +COMPATIBLE_IOCTL(NBD_DO_IT) +COMPATIBLE_IOCTL(NBD_CLEAR_SOCK) +COMPATIBLE_IOCTL(NBD_CLEAR_QUE) +COMPATIBLE_IOCTL(NBD_PRINT_DEBUG) +COMPATIBLE_IOCTL(NBD_SET_SIZE_BLOCKS) +COMPATIBLE_IOCTL(NBD_DISCONNECT) +/* device-mapper */ +COMPATIBLE_IOCTL(DM_VERSION) +COMPATIBLE_IOCTL(DM_REMOVE_ALL) +COMPATIBLE_IOCTL(DM_DEV_CREATE) +COMPATIBLE_IOCTL(DM_DEV_REMOVE) +COMPATIBLE_IOCTL(DM_DEV_RELOAD) +COMPATIBLE_IOCTL(DM_DEV_SUSPEND) +COMPATIBLE_IOCTL(DM_DEV_RENAME) +COMPATIBLE_IOCTL(DM_DEV_DEPS) +COMPATIBLE_IOCTL(DM_DEV_STATUS) +COMPATIBLE_IOCTL(DM_TARGET_STATUS) +COMPATIBLE_IOCTL(DM_TARGET_WAIT) /* And these ioctls need translation */ HANDLE_IOCTL(MEMREADOOB32, mtd_rw_oob) HANDLE_IOCTL(MEMWRITEOOB32, mtd_rw_oob) @@ -3889,4 +4473,4 @@ HANDLE_IOCTL(BLKBSZGET_32, do_blkbszget) HANDLE_IOCTL(BLKBSZSET_32, do_blkbszset) HANDLE_IOCTL(BLKGETSIZE64_32, do_blkgetsize64) -IOCTL_TABLE_END +}; diff -Nru a/arch/ppc64/kernel/irq.c b/arch/ppc64/kernel/irq.c --- a/arch/ppc64/kernel/irq.c Fri Jun 13 00:37:27 2003 +++ b/arch/ppc64/kernel/irq.c Fri Jun 13 00:37:27 2003 @@ -212,8 +212,7 @@ return -ENOENT; } -int request_irq(unsigned int irq, - irqreturn_t (*handler)(int, void *, struct pt_regs *), +int request_irq(unsigned int irq, void (*handler)(int, void *, struct pt_regs *), unsigned long irqflags, const char * devname, void *dev_id) { struct irqaction *action; @@ -696,7 +695,7 @@ struct proc_dir_entry *entry; char name [MAX_NAMELEN]; - if (!root_irq_dir || (irq_desc[irq].handler == NULL) || irq_dir[irq]) + if (!root_irq_dir || (irq_desc[irq].handler == NULL)) return; memset(name, 0, MAX_NAMELEN); @@ -744,7 +743,6 @@ } } -irqreturn_t no_action(int irq, void *dev, struct pt_regs *regs) +void no_action(int irq, void *dev, struct pt_regs *regs) { - return IRQ_NONE; } diff -Nru a/arch/ppc64/kernel/misc.S b/arch/ppc64/kernel/misc.S --- a/arch/ppc64/kernel/misc.S Fri Jun 13 00:37:27 2003 +++ b/arch/ppc64/kernel/misc.S Fri Jun 13 00:37:27 2003 @@ -170,14 +170,12 @@ */ LOADADDR(r10,naca) /* Get Naca address */ ld r10,0(r10) - LOADADDR(r11,systemcfg) /* Get systemcfg address */ - ld r11,0(r11) - lwz r7,DCACHEL1LINESIZE(r11)/* Get cache line size */ + lhz r7,DCACHEL1LINESIZE(r10) /* Get cache line size */ addi r5,r7,-1 andc r6,r3,r5 /* round low to line bdy */ subf r8,r6,r4 /* compute length */ add r8,r8,r5 /* ensure we get enough */ - lwz r9,DCACHEL1LOGLINESIZE(r10) /* Get log-2 of cache line size */ + lhz r9,DCACHEL1LOGLINESIZE(r10) /* Get log-2 of cache line size */ srw. r8,r8,r9 /* compute line count */ beqlr /* nothing to do? */ mtctr r8 @@ -188,12 +186,12 @@ /* Now invalidate the instruction cache */ - lwz r7,ICACHEL1LINESIZE(r11) /* Get Icache line size */ + lhz r7,ICACHEL1LINESIZE(r10) /* Get Icache line size */ addi r5,r7,-1 andc r6,r3,r5 /* round low to line bdy */ subf r8,r6,r4 /* compute length */ add r8,r8,r5 - lwz r9,ICACHEL1LOGLINESIZE(r10) /* Get log-2 of Icache line size */ + lhz r9,ICACHEL1LOGLINESIZE(r10) /* Get log-2 of Icache line size */ srw. r8,r8,r9 /* compute line count */ beqlr /* nothing to do? */ mtctr r8 @@ -219,14 +217,12 @@ */ LOADADDR(r10,naca) /* Get Naca address */ ld r10,0(r10) - LOADADDR(r11,systemcfg) /* Get systemcfg address */ - ld r11,0(r11) - lwz r7,DCACHEL1LINESIZE(r11) /* Get dcache line size */ + lhz r7,DCACHEL1LINESIZE(r10) /* Get dcache line size */ addi r5,r7,-1 andc r6,r3,r5 /* round low to line bdy */ subf r8,r6,r4 /* compute length */ add r8,r8,r5 /* ensure we get enough */ - lwz r9,DCACHEL1LOGLINESIZE(r10) /* Get log-2 of dcache line size */ + lhz r9,DCACHEL1LOGLINESIZE(r10) /* Get log-2 of dcache line size */ srw. r8,r8,r9 /* compute line count */ beqlr /* nothing to do? */ mtctr r8 @@ -253,11 +249,9 @@ /* Flush the dcache */ LOADADDR(r7,naca) ld r7,0(r7) - LOADADDR(r8,systemcfg) /* Get systemcfg address */ - ld r8,0(r8) clrrdi r3,r3,12 /* Page align */ - lwz r4,DCACHEL1LINESPERPAGE(r7) /* Get # dcache lines per page */ - lwz r5,DCACHEL1LINESIZE(r8) /* Get dcache line size */ + lhz r4,DCACHEL1LINESPERPAGE(r7) /* Get # dcache lines per page */ + lhz r5,DCACHEL1LINESIZE(r7) /* Get dcache line size */ mr r6,r3 mtctr r4 0: dcbst 0,r6 @@ -267,8 +261,8 @@ /* Now invalidate the icache */ - lwz r4,ICACHEL1LINESPERPAGE(r7) /* Get # icache lines per page */ - lwz r5,ICACHEL1LINESIZE(r8) /* Get icache line size */ + lhz r4,ICACHEL1LINESPERPAGE(r7) /* Get # icache lines per page */ + lhz r5,ICACHEL1LINESIZE(r7) /* Get icache line size */ mtctr r4 1: icbi 0,r3 add r3,r3,r5 @@ -580,7 +574,7 @@ .llong .sys32_ssetmask .llong .sys_setreuid /* 70 */ .llong .sys_setregid - .llong .sys32_sigsuspend + .llong .sys_sigsuspend .llong .compat_sys_sigpending .llong .sys32_sethostname .llong .compat_sys_setrlimit /* 75 */ @@ -743,7 +737,7 @@ .llong .sys_set_tid_address .llong .ppc32_fadvise64 .llong .sys_exit_group - .llong .ppc32_lookup_dcookie /* 235 */ + .llong .ppc32_lookup_dcookie /* 245 */ .llong .sys_epoll_create .llong .sys_epoll_ctl .llong .sys_epoll_wait @@ -818,13 +812,13 @@ .llong .sys_getppid .llong .sys_getpgrp /* 65 */ .llong .sys_setsid - .llong .sys_ni_syscall + .llong .sys_sigaction .llong .sys_sgetmask .llong .sys_ssetmask .llong .sys_setreuid /* 70 */ .llong .sys_setregid - .llong .sys_ni_syscall - .llong .sys_ni_syscall + .llong .sys_sigsuspend + .llong .sys_sigpending .llong .sys_sethostname .llong .sys_setrlimit /* 75 */ .llong .sys_ni_syscall /* old getrlimit syscall */ @@ -870,14 +864,14 @@ .llong .sys_sysinfo .llong .sys_ipc .llong .sys_fsync - .llong .sys_ni_syscall + .llong .ppc64_sigreturn .llong .sys_clone /* 120 */ .llong .sys_setdomainname .llong .ppc64_newuname .llong .sys_ni_syscall /* old modify_ldt syscall */ .llong .sys_adjtimex .llong .sys_mprotect /* 125 */ - .llong .sys_ni_syscall + .llong .sys_sigprocmask .llong .sys_ni_syscall /* old create_module syscall */ .llong .sys_init_module .llong .sys_delete_module diff -Nru a/arch/ppc64/kernel/module.c b/arch/ppc64/kernel/module.c --- a/arch/ppc64/kernel/module.c Fri Jun 13 00:37:27 2003 +++ b/arch/ppc64/kernel/module.c Fri Jun 13 00:37:27 2003 @@ -20,8 +20,6 @@ #include #include #include -#include -#include /* FIXME: We don't do .init separately. To do this, we'd need to have a separate r2 value in the init and core section, and stub between @@ -376,11 +374,15 @@ return 0; } +/* In arch/ppc64/mm/extable.c */ +extern void sort_ex_table(struct exception_table_entry *start, + struct exception_table_entry *finish); + int module_finalize(const Elf_Ehdr *hdr, - const Elf_Shdr *sechdrs, struct module *me) + const Elf_Shdr *sechdrs, + struct module *me) { - sort_ex_table((struct exception_table_entry *)me->extable, - (struct exception_table_entry *)me->extable + - me->num_exentries); + sort_ex_table(me->extable.entry, + me->extable.entry + me->extable.num_entries); return 0; } diff -Nru a/arch/ppc64/kernel/open_pic.c b/arch/ppc64/kernel/open_pic.c --- a/arch/ppc64/kernel/open_pic.c Fri Jun 13 00:37:27 2003 +++ b/arch/ppc64/kernel/open_pic.c Fri Jun 13 00:37:27 2003 @@ -111,6 +111,7 @@ * data has probably been corrupted and we're going to panic or deadlock later * anyway --Troy */ +extern unsigned long* _get_SP(void); #define check_arg_irq(irq) \ if (irq < open_pic_irq_offset || irq >= (NumSources+open_pic_irq_offset)){ \ printk(KERN_ERR "open_pic.c:%d: illegal irq %d\n", __LINE__, irq); \ @@ -764,11 +765,9 @@ openpic_eoi(); } -static irqreturn_t openpic_ipi_action(int cpl, void *dev_id, - struct pt_regs *regs) +static void openpic_ipi_action(int cpl, void *dev_id, struct pt_regs *regs) { smp_message_recv(cpl-openpic_vec_ipi, regs); - return IRQ_HANDLED; } #endif /* CONFIG_SMP */ diff -Nru a/arch/ppc64/kernel/open_pic_defs.h b/arch/ppc64/kernel/open_pic_defs.h --- a/arch/ppc64/kernel/open_pic_defs.h Fri Jun 13 00:37:27 2003 +++ b/arch/ppc64/kernel/open_pic_defs.h Fri Jun 13 00:37:27 2003 @@ -298,8 +298,7 @@ #ifdef CONFIG_SMP /* Interprocessor Interrupts */ static void openpic_initipi(u_int ipi, u_int pri, u_int vector); -static irqreturn_t openpic_ipi_action(int cpl, void *dev_id, - struct pt_regs *regs); +static void openpic_ipi_action(int cpl, void *dev_id, struct pt_regs *regs); #endif /* Timer Interrupts */ diff -Nru a/arch/ppc64/kernel/pSeries_lpar.c b/arch/ppc64/kernel/pSeries_lpar.c --- a/arch/ppc64/kernel/pSeries_lpar.c Fri Jun 13 00:37:27 2003 +++ b/arch/ppc64/kernel/pSeries_lpar.c Fri Jun 13 00:37:27 2003 @@ -110,6 +110,29 @@ lbuf[0], lbuf[1], &dummy, &dummy, &dummy); } +long plpar_eoi(unsigned long xirr) +{ + return plpar_hcall_norets(H_EOI, xirr); +} + +long plpar_cppr(unsigned long cppr) +{ + return plpar_hcall_norets(H_CPPR, cppr); +} + +long plpar_ipi(unsigned long servernum, + unsigned long mfrr) +{ + return plpar_hcall_norets(H_IPI, servernum, mfrr); +} + +long plpar_xirr(unsigned long *xirr_ret) +{ + unsigned long dummy; + return plpar_hcall(H_XIRR, 0, 0, 0, 0, + xirr_ret, &dummy, &dummy); +} + static void tce_build_pSeriesLP(struct TceTable *tbl, long tcenum, unsigned long uaddr, int direction ) { @@ -156,6 +179,66 @@ } } + +/* PowerPC Interrupts for lpar. */ +/* NOTE: this typedef is duplicated (for now) from xics.c! */ +typedef struct { + int (*xirr_info_get)(int cpu); + void (*xirr_info_set)(int cpu, int val); + void (*cppr_info)(int cpu, u8 val); + void (*qirr_info)(int cpu, u8 val); +} xics_ops; +static int pSeriesLP_xirr_info_get(int n_cpu) +{ + unsigned long lpar_rc; + unsigned long return_value; + + lpar_rc = plpar_xirr(&return_value); + if (lpar_rc != H_Success) { + panic(" bad return code xirr - rc = %lx \n", lpar_rc); + } + return ((int)(return_value)); +} + +static void pSeriesLP_xirr_info_set(int n_cpu, int value) +{ + unsigned long lpar_rc; + unsigned long val64 = value & 0xffffffff; + + lpar_rc = plpar_eoi(val64); + if (lpar_rc != H_Success) { + panic(" bad return code EOI - rc = %ld, value=%lx \n", lpar_rc, val64); + } +} + +static void pSeriesLP_cppr_info(int n_cpu, u8 value) +{ + unsigned long lpar_rc; + + lpar_rc = plpar_cppr(value); + if (lpar_rc != H_Success) { + panic(" bad return code cppr - rc = %lx \n", lpar_rc); + } +} + +static void pSeriesLP_qirr_info(int n_cpu , u8 value) +{ + unsigned long lpar_rc; + + lpar_rc = plpar_ipi(n_cpu, value); + if (lpar_rc != H_Success) { + panic(" bad return code qirr -ipi - rc = %lx \n", lpar_rc); + } +} + +xics_ops pSeriesLP_ops = { + pSeriesLP_xirr_info_get, + pSeriesLP_xirr_info_set, + pSeriesLP_cppr_info, + pSeriesLP_qirr_info +}; +/* end TAI-LPAR */ + int vtermno; /* virtual terminal# for udbg */ diff -Nru a/arch/ppc64/kernel/pacaData.c b/arch/ppc64/kernel/pacaData.c --- a/arch/ppc64/kernel/pacaData.c Fri Jun 13 00:37:27 2003 +++ b/arch/ppc64/kernel/pacaData.c Fri Jun 13 00:37:27 2003 @@ -20,7 +20,6 @@ #include struct naca_struct *naca; -struct systemcfg *systemcfg; /* The Paca is an array with one entry per processor. Each contains an * ItLpPaca, which contains the information shared between the @@ -66,9 +65,9 @@ struct paca_struct paca[MAX_PACAS] __page_aligned = { #ifdef CONFIG_PPC_ISERIES - PACAINITDATA( 0, 1, &xItLpQueue, 0, STAB0_VIRT_ADDR), + PACAINITDATA( 0, 1, &xItLpQueue, 0, 0xc000000000005000), #else - PACAINITDATA( 0, 1, 0, STAB0_PHYS_ADDR, STAB0_VIRT_ADDR), + PACAINITDATA( 0, 1, 0, 0x5000, 0xc000000000005000), #endif PACAINITDATA( 1, 0, 0, 0, 0), PACAINITDATA( 2, 0, 0, 0, 0), diff -Nru a/arch/ppc64/kernel/pci.c b/arch/ppc64/kernel/pci.c --- a/arch/ppc64/kernel/pci.c Fri Jun 13 00:37:27 2003 +++ b/arch/ppc64/kernel/pci.c Fri Jun 13 00:37:27 2003 @@ -21,7 +21,6 @@ #include #include #include -#include #include #include diff -Nru a/arch/ppc64/kernel/pci_dma.c b/arch/ppc64/kernel/pci_dma.c --- a/arch/ppc64/kernel/pci_dma.c Fri Jun 13 00:37:27 2003 +++ b/arch/ppc64/kernel/pci_dma.c Fri Jun 13 00:37:27 2003 @@ -134,7 +134,7 @@ dev = ppc64_isabridge_dev; if (!dev) return NULL; - if (systemcfg->platform == PLATFORM_ISERIES_LPAR) { + if (naca->platform == PLATFORM_ISERIES_LPAR) { return ISERIES_DEVNODE(dev)->DevTceTable; } else { return PCI_GET_DN(dev)->tce_table; @@ -723,8 +723,8 @@ */ busdn->bussubno = bus->number; create_pci_bus_tce_table((unsigned long)busdn); - } - create_tce_tables_for_busesLP(&bus->children); + } else + create_tce_tables_for_busesLP(&bus->children); } } @@ -732,7 +732,7 @@ struct pci_dev *dev; struct device_node *dn, *mydn; - if (systemcfg->platform == PLATFORM_PSERIES_LPAR) { + if (naca->platform == PLATFORM_PSERIES_LPAR) { create_tce_tables_for_busesLP(&pci_root_buses); } else { @@ -773,7 +773,7 @@ /* - Tce Table Share between buses, */ /* - Tce Table per logical slot. */ /*****************************************************************/ - if(systemcfg->platform == PLATFORM_ISERIES_LPAR) { + if(naca->platform == PLATFORM_ISERIES_LPAR) { struct iSeries_Device_Node* DevNode = (struct iSeries_Device_Node*)token; getTceTableParmsiSeries(DevNode,newTceTable); @@ -797,7 +797,7 @@ dn = (struct device_node *)token; phb = dn->phb; - if (systemcfg->platform == PLATFORM_PSERIES) + if (naca->platform == PLATFORM_PSERIES) getTceTableParmsPSeries(phb, dn, newTceTable); else getTceTableParmsPSeriesLP(phb, dn, newTceTable); @@ -1135,8 +1135,7 @@ /* Client asked for way to much space. This is checked later anyway */ /* It is easier to debug here for the drivers than in the tce tables.*/ if(order >= NUM_TCE_LEVELS) { - printk("PCI_DMA: pci_unmap_single 0x%lx size too" - " large: 0x%lx \n", (long)dma_handle, (long)size); + printk("PCI_DMA: pci_unmap_single 0x%lx size to large: 0x%lx \n",dma_handle,size); return; } diff -Nru a/arch/ppc64/kernel/process.c b/arch/ppc64/kernel/process.c --- a/arch/ppc64/kernel/process.c Fri Jun 13 00:37:27 2003 +++ b/arch/ppc64/kernel/process.c Fri Jun 13 00:37:27 2003 @@ -533,6 +533,8 @@ } while (count++ < 32); } +extern unsigned long *_get_SP(void); + void dump_stack(void) { show_tsk_stack(current, (unsigned long)_get_SP()); diff -Nru a/arch/ppc64/kernel/prom.c b/arch/ppc64/kernel/prom.c --- a/arch/ppc64/kernel/prom.c Fri Jun 13 00:37:27 2003 +++ b/arch/ppc64/kernel/prom.c Fri Jun 13 00:37:27 2003 @@ -118,6 +118,7 @@ #define FB_MAX 8 #endif +static int ppc64_is_smp; struct prom_t prom = { 0, /* entry */ @@ -300,9 +301,7 @@ unsigned long offset = reloc_offset(); struct prom_t *_prom = PTRRELOC(&prom); struct naca_struct *_naca = RELOC(naca); - struct systemcfg *_systemcfg = RELOC(systemcfg); - /* NOTE: _naca->debug_switch is already initialized. */ #ifdef DEBUG_PROM prom_print(RELOC("prom_initialize_naca: start...\n")); #endif @@ -321,35 +320,25 @@ * d-cache and i-cache sizes... -Peter */ if ( num_cpus == 1 ) { - u32 size, lsize; - - call_prom(RELOC("getprop"), 4, 1, node, - RELOC("d-cache-size"), - &size, sizeof(size)); + u32 size; call_prom(RELOC("getprop"), 4, 1, node, RELOC("d-cache-line-size"), - &lsize, sizeof(lsize)); - - _systemcfg->dCacheL1Size = size; - _systemcfg->dCacheL1LineSize = lsize; - _naca->dCacheL1LogLineSize = __ilog2(lsize); - _naca->dCacheL1LinesPerPage = PAGE_SIZE/lsize; - - call_prom(RELOC("getprop"), 4, 1, node, - RELOC("i-cache-size"), &size, sizeof(size)); + _naca->dCacheL1LineSize = size; + _naca->dCacheL1LogLineSize = __ilog2(size); + _naca->dCacheL1LinesPerPage = PAGE_SIZE / size; + call_prom(RELOC("getprop"), 4, 1, node, RELOC("i-cache-line-size"), - &lsize, sizeof(lsize)); + &size, sizeof(size)); - _systemcfg->iCacheL1Size = size; - _systemcfg->iCacheL1LineSize = lsize; - _naca->iCacheL1LogLineSize = __ilog2(lsize); - _naca->iCacheL1LinesPerPage = PAGE_SIZE/lsize; + _naca->iCacheL1LineSize = size; + _naca->iCacheL1LogLineSize = __ilog2(size); + _naca->iCacheL1LinesPerPage = PAGE_SIZE / size; - if (_systemcfg->platform == PLATFORM_PSERIES_LPAR) { + if (_naca->platform == PLATFORM_PSERIES_LPAR) { u32 pft_size[2]; call_prom(RELOC("getprop"), 4, 1, node, RELOC("ibm,pft-size"), @@ -419,17 +408,20 @@ } /* We gotta have at least 1 cpu... */ - if ( (_systemcfg->processorCount = num_cpus) < 1 ) + if (num_cpus < 1) PROM_BUG(); - _systemcfg->physicalMemorySize = lmb_phys_mem_size(); + if (num_cpus > 1) + RELOC(ppc64_is_smp) = 1; + + _naca->physicalMemorySize = lmb_phys_mem_size(); - if (_systemcfg->platform == PLATFORM_PSERIES) { + if (_naca->platform == PLATFORM_PSERIES) { unsigned long rnd_mem_size, pteg_count; /* round mem_size up to next power of 2 */ - rnd_mem_size = 1UL << __ilog2(_systemcfg->physicalMemorySize); - if (rnd_mem_size < _systemcfg->physicalMemorySize) + rnd_mem_size = 1UL << __ilog2(_naca->physicalMemorySize); + if (rnd_mem_size < _naca->physicalMemorySize) rnd_mem_size <<= 1; /* # pages / 2 */ @@ -450,43 +442,49 @@ */ _naca->slb_size = 64; - /* Add an eye catcher and the systemcfg layout version number */ - strcpy(_systemcfg->eye_catcher, RELOC("SYSTEMCFG:PPC64")); - _systemcfg->version.major = SYSTEMCFG_MAJOR; - _systemcfg->version.minor = SYSTEMCFG_MINOR; - _systemcfg->processor = _get_PVR(); - #ifdef DEBUG_PROM - prom_print(RELOC("systemcfg->processorCount = 0x")); - prom_print_hex(_systemcfg->processorCount); + prom_print(RELOC("naca->physicalMemorySize = 0x")); + prom_print_hex(_naca->physicalMemorySize); prom_print_nl(); - prom_print(RELOC("systemcfg->physicalMemorySize = 0x")); - prom_print_hex(_systemcfg->physicalMemorySize); + prom_print(RELOC("naca->pftSize = 0x")); + prom_print_hex(_naca->pftSize); prom_print_nl(); - prom_print(RELOC("naca->pftSize = 0x")); - prom_print_hex(_naca->pftSize); + prom_print(RELOC("naca->dCacheL1LineSize = 0x")); + prom_print_hex(_naca->dCacheL1LineSize); + prom_print_nl(); + + prom_print(RELOC("naca->dCacheL1LogLineSize = 0x")); + prom_print_hex(_naca->dCacheL1LogLineSize); + prom_print_nl(); + + prom_print(RELOC("naca->dCacheL1LinesPerPage = 0x")); + prom_print_hex(_naca->dCacheL1LinesPerPage); prom_print_nl(); - prom_print(RELOC("systemcfg->dCacheL1LineSize = 0x")); - prom_print_hex(_systemcfg->dCacheL1LineSize); + prom_print(RELOC("naca->iCacheL1LineSize = 0x")); + prom_print_hex(_naca->iCacheL1LineSize); prom_print_nl(); - prom_print(RELOC("systemcfg->iCacheL1LineSize = 0x")); - prom_print_hex(_systemcfg->iCacheL1LineSize); + prom_print(RELOC("naca->iCacheL1LogLineSize = 0x")); + prom_print_hex(_naca->iCacheL1LogLineSize); prom_print_nl(); - prom_print(RELOC("naca->serialPortAddr = 0x")); + prom_print(RELOC("naca->iCacheL1LinesPerPage = 0x")); + prom_print_hex(_naca->iCacheL1LinesPerPage); + prom_print_nl(); + + prom_print(RELOC("naca->serialPortAddr = 0x")); prom_print_hex(_naca->serialPortAddr); prom_print_nl(); - prom_print(RELOC("naca->interrupt_controller = 0x")); + prom_print(RELOC("naca->interrupt_controller = 0x")); prom_print_hex(_naca->interrupt_controller); prom_print_nl(); - prom_print(RELOC("systemcfg->platform = 0x")); - prom_print_hex(_systemcfg->platform); + prom_print(RELOC("naca->platform = 0x")); + prom_print_hex(_naca->platform); prom_print_nl(); prom_print(RELOC("prom_initialize_naca: end...\n")); @@ -551,7 +549,7 @@ unsigned long offset = reloc_offset(); struct prom_t *_prom = PTRRELOC(&prom); struct rtas_t *_rtas = PTRRELOC(&rtas); - struct systemcfg *_systemcfg = RELOC(systemcfg); + struct naca_struct *_naca = RELOC(naca); ihandle prom_rtas; u32 getprop_rval; @@ -567,7 +565,7 @@ RELOC("ibm,hypertas-functions"), hypertas_funcs, sizeof(hypertas_funcs))) > 0) { - _systemcfg->platform = PLATFORM_PSERIES_LPAR; + _naca->platform = PLATFORM_PSERIES_LPAR; } call_prom(RELOC("getprop"), @@ -584,7 +582,7 @@ * of physical memory (or within the RMO region) because RTAS * runs in 32-bit mode and relocate off. */ - if ( _systemcfg->platform == PLATFORM_PSERIES_LPAR ) { + if ( _naca->platform == PLATFORM_PSERIES_LPAR ) { struct lmb *_lmb = PTRRELOC(&lmb); rtas_region = min(_lmb->rmo_size, RTAS_INSTANTIATE_MAX); } @@ -769,21 +767,13 @@ * By doing this, we avoid the pitfalls of trying to DMA to * MMIO space and the DMA alias hole. */ - /* - * On POWER4, firmware sets the TCE region by assuming - * each TCE table is 8MB. Using this memory for anything - * else will impact performance, so we always allocate 8MB. - * Anton - * - * XXX FIXME use a cpu feature here - */ - minsize = 8UL << 20; + minsize = 4UL << 20; /* Align to the greater of the align or size */ - align = max(minalign, minsize); + align = (minalign < minsize) ? minsize : minalign; /* Carve out storage for the TCE table. */ - base = lmb_alloc(minsize, align); + base = lmb_alloc(8UL << 20, 8UL << 20); if ( !base ) { prom_print(RELOC("ERROR, cannot find space for TCE table.\n")); @@ -885,7 +875,7 @@ prom_hold_cpus(unsigned long mem) { unsigned long i; - unsigned int cpuid; + unsigned int reg; phandle node; unsigned long offset = reloc_offset(); char type[64], *path; @@ -895,13 +885,9 @@ unsigned long *spinloop = __v2a(&__secondary_hold_spinloop); unsigned long *acknowledge = __v2a(&__secondary_hold_acknowledge); unsigned long secondary_hold = (unsigned long)__v2a(*PTRRELOC((unsigned long *)__secondary_hold)); - struct systemcfg *_systemcfg = RELOC(systemcfg); struct paca_struct *_xPaca = PTRRELOC(&paca[0]); struct prom_t *_prom = PTRRELOC(&prom); - /* Initially, we must have one active CPU. */ - _systemcfg->processorCount = 1; - #ifdef DEBUG_PROM prom_print(RELOC("prom_hold_cpus: start...\n")); prom_print(RELOC(" 1) spinloop = 0x")); @@ -947,12 +933,12 @@ if (strcmp(type, RELOC("okay")) != 0) continue; - cpuid = -1; + reg = -1; call_prom(RELOC("getprop"), 4, 1, node, RELOC("reg"), - &cpuid, sizeof(cpuid)); + ®, sizeof(reg)); /* Only need to start secondary procs, not ourself. */ - if ( cpuid == _prom->cpu ) + if ( reg == _prom->cpu ) continue; path = (char *) mem; @@ -964,7 +950,7 @@ #ifdef DEBUG_PROM prom_print_nl(); prom_print(RELOC("cpu hw idx = 0x")); - prom_print_hex(cpuid); + prom_print_hex(reg); prom_print_nl(); #endif prom_print(RELOC("starting cpu ")); @@ -992,8 +978,9 @@ prom_print(RELOC(" 3) secondary_hold = 0x")); prom_print_hex(secondary_hold); prom_print_nl(); + prom_print_nl(); #endif - call_prom(RELOC("start-cpu"), 3, 0, node, secondary_hold, cpuid); + call_prom(RELOC("start-cpu"), 3, 0, node, secondary_hold, reg); prom_print(RELOC("...")); for ( i = 0 ; (i < 100000000) && (*acknowledge == ((unsigned long)-1)); i++ ) ; @@ -1005,11 +992,10 @@ prom_print_nl(); } #endif - if (*acknowledge == cpuid) { + if (*acknowledge == reg) { prom_print(RELOC("ok\n")); /* Set the number of active processors. */ - _systemcfg->processorCount++; - _xPaca[cpuid].active = 1; + _xPaca[reg].active = 1; } else { prom_print(RELOC("failed: ")); prom_print_hex(*acknowledge); @@ -1038,8 +1024,8 @@ } } _xPaca[i+1].active = 1; + RELOC(hmt_thread_data)[i].threadid = i+1; } - _systemcfg->processorCount *= 2; } else { prom_print(RELOC("Processor is not HMT capable\n")); } @@ -1060,21 +1046,20 @@ prom_init(unsigned long r3, unsigned long r4, unsigned long pp, unsigned long r6, unsigned long r7) { - int chrp = 0; unsigned long mem; - ihandle prom_mmu, prom_op, prom_root, prom_cpu; + ihandle prom_root, prom_cpu; phandle cpu_pkg; unsigned long offset = reloc_offset(); - long l, sz; + long l; char *p, *d; unsigned long phys; u32 getprop_rval; - struct systemcfg *_systemcfg = RELOC(systemcfg); + struct naca_struct *_naca = RELOC(naca); struct paca_struct *_xPaca = PTRRELOC(&paca[0]); struct prom_t *_prom = PTRRELOC(&prom); /* Default machine type. */ - _systemcfg->platform = PLATFORM_PSERIES; + _naca->platform = PLATFORM_PSERIES; #if 0 /* Reset klimit to take into account the embedded system map */ @@ -1164,8 +1149,6 @@ mem = prom_bi_rec_reserve(mem); - mem = check_display(mem); - prom_instantiate_rtas(); /* Initialize some system info into the Naca early... */ @@ -1175,9 +1158,11 @@ * following, regardless of whether we have an SMP * kernel or not. */ - if (_systemcfg->processorCount > 1) + if (RELOC(ppc64_is_smp)) prom_hold_cpus(mem); + mem = check_display(mem); + #ifdef DEBUG_PROM prom_print(RELOC("copying OF device tree...\n")); #endif @@ -1187,7 +1172,7 @@ lmb_reserve(0, __pa(RELOC(klimit))); - if (_systemcfg->platform == PLATFORM_PSERIES) + if (_naca->platform == PLATFORM_PSERIES) prom_initialize_tce_table(); prom_print(RELOC("Calling quiesce ...\n")); diff -Nru a/arch/ppc64/kernel/ras.c b/arch/ppc64/kernel/ras.c --- a/arch/ppc64/kernel/ras.c Fri Jun 13 00:37:27 2003 +++ b/arch/ppc64/kernel/ras.c Fri Jun 13 00:37:27 2003 @@ -54,10 +54,8 @@ #include #include -static irqreturn_t ras_epow_interrupt(int irq, void *dev_id, - struct pt_regs * regs); -static irqreturn_t ras_error_interrupt(int irq, void *dev_id, - struct pt_regs * regs); +static void ras_epow_interrupt(int irq, void *dev_id, struct pt_regs * regs); +static void ras_error_interrupt(int irq, void *dev_id, struct pt_regs * regs); void init_ras_IRQ(void); /* #define DEBUG */ @@ -75,7 +73,7 @@ &len))) { for(i=0; i<(len / sizeof(*ireg)); i++) { request_irq(virt_irq_create_mapping(*(ireg)) + NUM_8259_INTERRUPTS, - ras_error_interrupt, 0, + &ras_error_interrupt, 0, "RAS_ERROR", NULL); ireg++; } @@ -86,7 +84,7 @@ &len))) { for(i=0; i<(len / sizeof(*ireg)); i++) { request_irq(virt_irq_create_mapping(*(ireg)) + NUM_8259_INTERRUPTS, - ras_epow_interrupt, 0, + &ras_epow_interrupt, 0, "RAS_EPOW", NULL); ireg++; } @@ -100,7 +98,7 @@ * to examine the type of power failure and take appropriate action where * the time horizon permits something useful to be done. */ -static irqreturn_t +static void ras_epow_interrupt(int irq, void *dev_id, struct pt_regs * regs) { struct rtas_error_log log_entry; @@ -116,8 +114,7 @@ udbg_printf("EPOW <0x%lx 0x%lx>\n", *((unsigned long *)&log_entry), status); printk(KERN_WARNING - "EPOW <0x%lx 0x%lx>\n",*((unsigned long *)&log_entry), status); - return IRQ_HANDLED; + "EPOW <0x%lx 0x%lx>\n",*((unsigned long *)&log_entry), status); } /* @@ -128,7 +125,7 @@ * For nonrecoverable errors, an error is logged and we stop all processing * as quickly as possible in order to prevent propagation of the failure. */ -static irqreturn_t +static void ras_error_interrupt(int irq, void *dev_id, struct pt_regs * regs) { struct rtas_error_log log_entry; @@ -161,6 +158,7 @@ printk(KERN_WARNING "Warning: Recoverable hardware error <0x%lx 0x%lx>\n", *((unsigned long *)&log_entry), status); + + return; } - return IRQ_HANDLED; } diff -Nru a/arch/ppc64/kernel/rtas-proc.c b/arch/ppc64/kernel/rtas-proc.c --- a/arch/ppc64/kernel/rtas-proc.c Fri Jun 13 00:37:27 2003 +++ b/arch/ppc64/kernel/rtas-proc.c Fri Jun 13 00:37:27 2003 @@ -201,7 +201,7 @@ struct proc_dir_entry *entry; rtas_node = find_devices("rtas"); - if ((rtas_node == NULL) || (systemcfg->platform == PLATFORM_ISERIES_LPAR)) { + if ((rtas_node == NULL) || (naca->platform == PLATFORM_ISERIES_LPAR)) { return; } @@ -506,27 +506,21 @@ int error, char * buf) { /* Defined return vales */ - const char * key_switch[] = { "Off\t", "Normal\t", "Secure\t", - "Maintenance" }; + const char * key_switch[] = { "Off\t", "Normal\t", "Secure\t", "Mainenance" }; const char * enclosure_switch[] = { "Closed", "Open" }; const char * lid_status[] = { " ", "Open", "Closed" }; - const char * power_source[] = { "AC\t", "Battery", - "AC & Battery" }; + const char * power_source[] = { "AC\t", "Battery", "AC & Battery" }; const char * battery_remaining[] = { "Very Low", "Low", "Mid", "High" }; const char * epow_sensor[] = { "EPOW Reset", "Cooling warning", "Power warning", "System shutdown", "System halt", "EPOW main enclosure", "EPOW power off" }; - const char * battery_cyclestate[] = { "None", "In progress", - "Requested" }; - const char * battery_charging[] = { "Charging", "Discharching", - "No current flow" }; - const char * ibm_drconnector[] = { "Empty", "Present", "Unusable", - "Exchange" }; + const char * battery_cyclestate[] = { "None", "In progress", "Requested" }; + const char * battery_charging[] = { "Charging", "Discharching", "No current flow" }; + const char * ibm_drconnector[] = { "Empty", "Present" }; const char * ibm_intqueue[] = { "Disabled", "Enabled" }; int have_strings = 0; - int num_states = 0; int temperature = 0; int unknown = 0; int n = 0; @@ -536,20 +530,13 @@ switch (s.token) { case KEY_SWITCH: n += sprintf(buf+n, "Key switch:\t"); - num_states = sizeof(key_switch) / sizeof(char *); - if (state < num_states) { - n += sprintf(buf+n, "%s\t", key_switch[state]); - have_strings = 1; - } + n += sprintf(buf+n, "%s\t", key_switch[state]); + have_strings = 1; break; case ENCLOSURE_SWITCH: n += sprintf(buf+n, "Enclosure switch:\t"); - num_states = sizeof(enclosure_switch) / sizeof(char *); - if (state < num_states) { - n += sprintf(buf+n, "%s\t", - enclosure_switch[state]); - have_strings = 1; - } + n += sprintf(buf+n, "%s\t", enclosure_switch[state]); + have_strings = 1; break; case THERMAL_SENSOR: n += sprintf(buf+n, "Temp. (°C/°F):\t"); @@ -557,63 +544,39 @@ break; case LID_STATUS: n += sprintf(buf+n, "Lid status:\t"); - num_states = sizeof(lid_status) / sizeof(char *); - if (state < num_states) { - n += sprintf(buf+n, "%s\t", lid_status[state]); - have_strings = 1; - } + n += sprintf(buf+n, "%s\t", lid_status[state]); + have_strings = 1; break; case POWER_SOURCE: n += sprintf(buf+n, "Power source:\t"); - num_states = sizeof(power_source) / sizeof(char *); - if (state < num_states) { - n += sprintf(buf+n, "%s\t", - power_source[state]); - have_strings = 1; - } + n += sprintf(buf+n, "%s\t", power_source[state]); + have_strings = 1; break; case BATTERY_VOLTAGE: n += sprintf(buf+n, "Battery voltage:\t"); break; case BATTERY_REMAINING: n += sprintf(buf+n, "Battery remaining:\t"); - num_states = sizeof(battery_remaining) / sizeof(char *); - if (state < num_states) - { - n += sprintf(buf+n, "%s\t", - battery_remaining[state]); - have_strings = 1; - } + n += sprintf(buf+n, "%s\t", battery_remaining[state]); + have_strings = 1; break; case BATTERY_PERCENTAGE: n += sprintf(buf+n, "Battery percentage:\t"); break; case EPOW_SENSOR: n += sprintf(buf+n, "EPOW Sensor:\t"); - num_states = sizeof(epow_sensor) / sizeof(char *); - if (state < num_states) { - n += sprintf(buf+n, "%s\t", epow_sensor[state]); - have_strings = 1; - } + n += sprintf(buf+n, "%s\t", epow_sensor[state]); + have_strings = 1; break; case BATTERY_CYCLESTATE: n += sprintf(buf+n, "Battery cyclestate:\t"); - num_states = sizeof(battery_cyclestate) / - sizeof(char *); - if (state < num_states) { - n += sprintf(buf+n, "%s\t", - battery_cyclestate[state]); - have_strings = 1; - } + n += sprintf(buf+n, "%s\t", battery_cyclestate[state]); + have_strings = 1; break; case BATTERY_CHARGING: n += sprintf(buf+n, "Battery Charging:\t"); - num_states = sizeof(battery_charging) / sizeof(char *); - if (state < num_states) { - n += sprintf(buf+n, "%s\t", - battery_charging[state]); - have_strings = 1; - } + n += sprintf(buf+n, "%s\t", battery_charging[state]); + have_strings = 1; break; case IBM_SURVEILLANCE: n += sprintf(buf+n, "Surveillance:\t"); @@ -626,24 +589,16 @@ break; case IBM_DRCONNECTOR: n += sprintf(buf+n, "DR connector:\t"); - num_states = sizeof(ibm_drconnector) / sizeof(char *); - if (state < num_states) { - n += sprintf(buf+n, "%s\t", - ibm_drconnector[state]); - have_strings = 1; - } + n += sprintf(buf+n, "%s\t", ibm_drconnector[state]); + have_strings = 1; break; case IBM_POWERSUPPLY: n += sprintf(buf+n, "Powersupply:\t"); break; case IBM_INTQUEUE: n += sprintf(buf+n, "Interrupt queue:\t"); - num_states = sizeof(ibm_intqueue) / sizeof(char *); - if (state < num_states) { - n += sprintf(buf+n, "%s\t", - ibm_intqueue[state]); - have_strings = 1; - } + n += sprintf(buf+n, "%s\t", ibm_intqueue[state]); + have_strings = 1; break; default: n += sprintf(buf+n, "Unkown sensor (type %d), ignoring it\n", diff -Nru a/arch/ppc64/kernel/rtas.c b/arch/ppc64/kernel/rtas.c --- a/arch/ppc64/kernel/rtas.c Fri Jun 13 00:37:27 2003 +++ b/arch/ppc64/kernel/rtas.c Fri Jun 13 00:37:27 2003 @@ -18,7 +18,6 @@ #include #include -#include #include #include #include @@ -28,6 +27,7 @@ #include #include +struct proc_dir_entry *rtas_proc_dir; /* /proc/ppc64/rtas dir */ struct flash_block_list_header rtas_firmware_flash_list = {0, 0}; /* @@ -216,11 +216,7 @@ image_size += f->blocks[i].length; } next = f->next; - /* Don't translate NULL pointer for last entry */ - if(f->next) - f->next = (struct flash_block_list *)virt_to_absolute((unsigned long)f->next); - else - f->next = 0LL; + f->next = (struct flash_block_list *)virt_to_absolute((unsigned long)f->next); /* make num_blocks into the version/length field */ f->num_blocks = (FLASH_BLOCK_LIST_VERSION << 56) | ((f->num_blocks+1)*16); } @@ -287,7 +283,7 @@ rtas_power_off(); } -EXPORT_SYMBOL(proc_ppc64); +EXPORT_SYMBOL(rtas_proc_dir); EXPORT_SYMBOL(rtas_firmware_flash_list); EXPORT_SYMBOL(rtas_token); EXPORT_SYMBOL(rtas_call); diff -Nru a/arch/ppc64/kernel/rtas_flash.c b/arch/ppc64/kernel/rtas_flash.c --- a/arch/ppc64/kernel/rtas_flash.c Fri Jun 13 00:37:27 2003 +++ b/arch/ppc64/kernel/rtas_flash.c Fri Jun 13 00:37:27 2003 @@ -210,7 +210,7 @@ { struct proc_dir_entry *ent = NULL; - if (!proc_ppc64.rtas) { + if (!rtas_proc_dir) { printk(KERN_WARNING "rtas proc dir does not already exist"); return -ENOENT; } @@ -218,7 +218,7 @@ if (rtas_token("ibm,update-flash-64-and-reboot") != RTAS_UNKNOWN_SERVICE) flash_possible = 1; - if ((ent = create_proc_entry(FIRMWARE_FLASH_NAME, S_IRUSR | S_IWUSR, proc_ppc64.rtas)) != NULL) { + if ((ent = create_proc_entry(FIRMWARE_FLASH_NAME, S_IRUSR | S_IWUSR, rtas_proc_dir)) != NULL) { ent->nlink = 1; ent->proc_fops = &rtas_flash_operations; ent->owner = THIS_MODULE; @@ -228,9 +228,9 @@ void __exit rtas_flash_cleanup(void) { - if (!proc_ppc64.rtas) + if (!rtas_proc_dir) return; - remove_proc_entry(FIRMWARE_FLASH_NAME, proc_ppc64.rtas); + remove_proc_entry(FIRMWARE_FLASH_NAME, rtas_proc_dir); } module_init(rtas_flash_init); diff -Nru a/arch/ppc64/kernel/setup.c b/arch/ppc64/kernel/setup.c --- a/arch/ppc64/kernel/setup.c Fri Jun 13 00:37:27 2003 +++ b/arch/ppc64/kernel/setup.c Fri Jun 13 00:37:27 2003 @@ -142,6 +142,9 @@ void setup_system(unsigned long r3, unsigned long r4, unsigned long r5, unsigned long r6, unsigned long r7) { + /* This should be fixed properly in kernel/resource.c */ + iomem_resource.end = MEM_SPACE_LIMIT; + #ifdef CONFIG_XMON_DEFAULT debugger = xmon; debugger_bpt = xmon_bpt; @@ -153,10 +156,10 @@ #ifdef CONFIG_PPC_ISERIES /* pSeries systems are identified in prom.c via OF. */ if ( itLpNaca.xLparInstalled == 1 ) - systemcfg->platform = PLATFORM_ISERIES_LPAR; + naca->platform = PLATFORM_ISERIES_LPAR; #endif - switch (systemcfg->platform) { + switch (naca->platform) { #ifdef CONFIG_PPC_ISERIES case PLATFORM_ISERIES_LPAR: iSeries_init_early(); @@ -182,7 +185,7 @@ #endif } - if (systemcfg->platform & PLATFORM_PSERIES) { + if (naca->platform & PLATFORM_PSERIES) { early_console_initialized = 1; register_console(&udbg_console); } @@ -190,27 +193,32 @@ printk("Starting Linux PPC64 %s\n", UTS_RELEASE); printk("-----------------------------------------------------\n"); - printk("naca = 0x%p\n", naca); - printk("naca->pftSize = 0x%lx\n", naca->pftSize); - printk("naca->debug_switch = 0x%lx\n", naca->debug_switch); - printk("naca->interrupt_controller = 0x%d\n", naca->interrupt_controller); - printk("systemcf = 0x%p\n", systemcfg); - printk("systemcfg->processorCount = 0x%x\n", systemcfg->processorCount); - printk("systemcfg->physicalMemorySize = 0x%lx\n", systemcfg->physicalMemorySize); - printk("systemcfg->dCacheL1LineSize = 0x%x\n", systemcfg->dCacheL1LineSize); - printk("systemcfg->iCacheL1LineSize = 0x%x\n", systemcfg->iCacheL1LineSize); - printk("htab_data.htab = 0x%p\n", htab_data.htab); - printk("htab_data.num_ptegs = 0x%lx\n", htab_data.htab_num_ptegs); + printk("naca = 0x%p\n", naca); +#if 0 + printk("naca->processorCount = 0x%x\n", naca->processorCount); +#endif + printk("naca->physicalMemorySize = 0x%lx\n", naca->physicalMemorySize); + printk("naca->dCacheL1LineSize = 0x%x\n", naca->dCacheL1LineSize); + printk("naca->dCacheL1LogLineSize = 0x%x\n", naca->dCacheL1LogLineSize); + printk("naca->dCacheL1LinesPerPage = 0x%x\n", naca->dCacheL1LinesPerPage); + printk("naca->iCacheL1LineSize = 0x%x\n", naca->iCacheL1LineSize); + printk("naca->iCacheL1LogLineSize = 0x%x\n", naca->iCacheL1LogLineSize); + printk("naca->iCacheL1LinesPerPage = 0x%x\n", naca->iCacheL1LinesPerPage); + printk("naca->pftSize = 0x%lx\n", naca->pftSize); + printk("naca->debug_switch = 0x%lx\n", naca->debug_switch); + printk("naca->interrupt_controller = 0x%d\n", naca->interrupt_controller); + printk("htab_data.htab = 0x%p\n", htab_data.htab); + printk("htab_data.num_ptegs = 0x%lx\n", htab_data.htab_num_ptegs); printk("-----------------------------------------------------\n"); - if (systemcfg->platform & PLATFORM_PSERIES) { + if (naca->platform & PLATFORM_PSERIES) { finish_device_tree(); chrp_init(r3, r4, r5, r6, r7); } mm_init_ppc64(); - switch (systemcfg->platform) { + switch (naca->platform) { #ifdef CONFIG_PPC_ISERIES case PLATFORM_ISERIES_LPAR: iSeries_init(); @@ -304,7 +312,7 @@ * Assume here that all clock rates are the same in a * smp system. -- Cort */ - if (systemcfg->platform != PLATFORM_ISERIES_LPAR) { + if (naca->platform != PLATFORM_ISERIES_LPAR) { struct device_node *cpu_node; int *fp; @@ -508,8 +516,8 @@ * Systems with OF can look in the properties on the cpu node(s) * for a possibly more accurate value. */ - dcache_bsize = systemcfg->dCacheL1LineSize; - icache_bsize = systemcfg->iCacheL1LineSize; + dcache_bsize = naca->dCacheL1LineSize; + icache_bsize = naca->iCacheL1LineSize; /* reboot on panic */ panic_timeout = 180; diff -Nru a/arch/ppc64/kernel/signal.c b/arch/ppc64/kernel/signal.c --- a/arch/ppc64/kernel/signal.c Fri Jun 13 00:37:27 2003 +++ b/arch/ppc64/kernel/signal.c Fri Jun 13 00:37:27 2003 @@ -43,29 +43,57 @@ #endif #define GP_REGS_SIZE MIN(sizeof(elf_gregset_t), sizeof(struct pt_regs)) -#define FP_REGS_SIZE sizeof(elf_fpregset_t) -#define TRAMP_TRACEBACK 3 -#define TRAMP_SIZE 6 +/* + * These are the flags in the MSR that the user is allowed to change + * by modifying the saved value of the MSR on the stack. SE and BE + * should not be in this list since gdb may want to change these. I.e, + * you should be able to step out of a signal handler to see what + * instruction executes next after the signal handler completes. + * Alternately, if you stepped into a signal handler, you should be + * able to continue 'til the next breakpoint from within the signal + * handler, even if the handler returns. + */ +#if 0 +#define MSR_USERCHANGE (MSR_FE0 | MSR_FE1) +#else +/* + * glibc tries to set FE0/FE1 via a signal handler. Since it only ever + * sets both bits and this is the default setting we now disable this + * behaviour. This is done to insure the new prctl which alters FE0/FE1 does + * not get overriden by glibc. Setting and clearing FE0/FE1 via signal + * handler has always been bogus since load_up_fpu used to set FE0/FE1 + * unconditionally. + */ +#define MSR_USERCHANGE 0 +#endif /* - * When we have signals to deliver, we set up on the user stack, - * going down from the original stack pointer: - * 1) a rt_sigframe struct which contains the ucontext - * 2) a gap of __SIGNAL_FRAMESIZE bytes which acts as a dummy caller - * frame for the signal handler. + * When we have signals to deliver, we set up on the + * user stack, going down from the original stack pointer: + * a sigregs struct + * one or more sigcontext structs with + * a gap of __SIGNAL_FRAMESIZE bytes + * + * Each of these things must be a multiple of 16 bytes in size. + * */ +struct sigregs { + elf_gregset_t gp_regs; + double fp_regs[ELF_NFPREG]; + unsigned int tramp[2]; + /* 64 bit API allows for 288 bytes below sp before + decrementing it. */ + int abigap[72]; +}; -struct rt_sigframe { - /* sys_rt_sigreturn requires the ucontext be the first field */ - struct ucontext uc; - unsigned long _unused[2]; - unsigned int tramp[TRAMP_SIZE]; +struct rt_sigframe +{ + unsigned long _unused[2]; struct siginfo *pinfo; void *puc; struct siginfo info; - /* 64 bit ABI allows for 288 bytes below sp before decrementing it. */ - char abigap[288]; + struct ucontext uc; }; @@ -74,6 +102,37 @@ /* * Atomically swap in the new signal mask, and wait for a signal. */ +long sys_sigsuspend(old_sigset_t mask, int p2, int p3, int p4, int p6, int p7, + struct pt_regs *regs) +{ + sigset_t saveset; + + mask &= _BLOCKABLE; + spin_lock_irq(¤t->sighand->siglock); + saveset = current->blocked; + siginitset(¤t->blocked, mask); + recalc_sigpending(); + spin_unlock_irq(¤t->sighand->siglock); + + regs->result = -EINTR; + regs->gpr[3] = EINTR; + regs->ccr |= 0x10000000; + while (1) { + current->state = TASK_INTERRUPTIBLE; + schedule(); + if (do_signal(&saveset, regs)) + /* + * If a signal handler needs to be called, + * do_signal() has set R3 to the signal number (the + * first argument of the signal handler), so don't + * overwrite that with EINTR ! + * In the other cases, do_signal() doesn't touch + * R3, so it's still set to -EINTR (see above). + */ + return regs->gpr[3]; + } +} + long sys_rt_sigsuspend(sigset_t *unewset, size_t sigsetsize, int p3, int p4, int p6, int p7, struct pt_regs *regs) { @@ -111,232 +170,339 @@ return do_sigaltstack(uss, uoss, regs->gpr[1]); } - -/* - * Set up the sigcontext for the signal frame. - */ - -static int -setup_sigcontext(struct sigcontext *sc, struct pt_regs *regs, - int signr, sigset_t *set, unsigned long handler) +long sys_sigaction(int sig, const struct old_sigaction *act, + struct old_sigaction *oact) { - int err = 0; + struct k_sigaction new_ka, old_ka; + int ret; - if (regs->msr & MSR_FP) - giveup_fpu(current); + if (act) { + old_sigset_t mask; - current->thread.saved_msr = regs->msr & ~(MSR_FP | MSR_FE0 | MSR_FE1); - regs->msr = current->thread.saved_msr | current->thread.fpexc_mode; - current->thread.saved_softe = regs->softe; - - err |= __put_user(&sc->gp_regs, &sc->regs); - err |= __copy_to_user(&sc->gp_regs, regs, GP_REGS_SIZE); - err |= __copy_to_user(&sc->fp_regs, ¤t->thread.fpr, FP_REGS_SIZE); - err |= __put_user(signr, &sc->signal); - err |= __put_user(handler, &sc->handler); - if (set != NULL) - err |= __put_user(set->sig[0], &sc->oldmask); + if (verify_area(VERIFY_READ, act, sizeof(*act)) || + __get_user(new_ka.sa.sa_handler, &act->sa_handler) || + __get_user(new_ka.sa.sa_restorer, &act->sa_restorer)) + return -EFAULT; + __get_user(new_ka.sa.sa_flags, &act->sa_flags); + __get_user(mask, &act->sa_mask); + siginitset(&new_ka.sa.sa_mask, mask); + } - regs->msr &= ~(MSR_FP | MSR_FE0 | MSR_FE1); - current->thread.fpscr = 0; + ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL); + if (!ret && oact) { + if (verify_area(VERIFY_WRITE, oact, sizeof(*oact)) || + __put_user(old_ka.sa.sa_handler, &oact->sa_handler) || + __put_user(old_ka.sa.sa_restorer, &oact->sa_restorer)) + return -EFAULT; + __put_user(old_ka.sa.sa_flags, &oact->sa_flags); + __put_user(old_ka.sa.sa_mask.sig[0], &oact->sa_mask); + } - return err; + return ret; } /* - * Restore the sigcontext from the signal frame. + * When we have rt signals to deliver, we set up on the + * user stack, going down from the original stack pointer: + * a sigregs struct + * one rt_sigframe struct (siginfo + ucontext) + * a gap of __SIGNAL_FRAMESIZE bytes + * + * Each of these things must be a multiple of 16 bytes in size. + * */ -static int -restore_sigcontext(struct pt_regs *regs, sigset_t *set, struct sigcontext *sc) +int sys_rt_sigreturn(unsigned long r3, unsigned long r4, unsigned long r5, + unsigned long r6, unsigned long r7, unsigned long r8, + struct pt_regs *regs) { - unsigned int err = 0; + struct rt_sigframe *rt_sf; + struct sigcontext sigctx; + struct sigregs *sr; + elf_gregset_t saved_regs; /* an array of ELF_NGREG unsigned longs */ + sigset_t set; + stack_t st; + rt_sf = (struct rt_sigframe *)(regs->gpr[1] + __SIGNAL_FRAMESIZE); + if (copy_from_user(&sigctx, &rt_sf->uc.uc_mcontext, sizeof(sigctx)) + || copy_from_user(&set, &rt_sf->uc.uc_sigmask, sizeof(set)) + || copy_from_user(&st, &rt_sf->uc.uc_stack, sizeof(st))) + goto badframe; + sigdelsetmask(&set, ~_BLOCKABLE); + spin_lock_irq(¤t->sighand->siglock); + current->blocked = set; + recalc_sigpending(); + spin_unlock_irq(¤t->sighand->siglock); if (regs->msr & MSR_FP) giveup_fpu(current); - err |= __copy_from_user(regs, &sc->gp_regs, GP_REGS_SIZE); - err |= __copy_from_user(¤t->thread.fpr, &sc->fp_regs, FP_REGS_SIZE); - current->thread.fpexc_mode = regs->msr & (MSR_FE0 | MSR_FE1); - if (set != NULL) - err |= __get_user(set->sig[0], &sc->oldmask); - - /* Don't allow the signal handler to change these modulo FE{0,1} */ - regs->msr = current->thread.saved_msr & ~(MSR_FP | MSR_FE0 | MSR_FE1); - regs->softe = current->thread.saved_softe; + /* restore registers - + * sigctx is initialized to point to the + * preamble frame (where registers are stored) + * see handle_signal() + */ + sr = (struct sigregs *)sigctx.regs; + if (copy_from_user(saved_regs, &sr->gp_regs, sizeof(sr->gp_regs))) + goto badframe; + saved_regs[PT_MSR] = (regs->msr & ~MSR_USERCHANGE) + | (saved_regs[PT_MSR] & MSR_USERCHANGE); + saved_regs[PT_SOFTE] = regs->softe; + memcpy(regs, saved_regs, GP_REGS_SIZE); + if (copy_from_user(current->thread.fpr, &sr->fp_regs, + sizeof(sr->fp_regs))) + goto badframe; + /* This function sets back the stack flags into + the current task structure. */ + sys_sigaltstack(&st, NULL, 0, 0, 0, 0, regs); - return err; + return regs->result; + +badframe: + do_exit(SIGSEGV); } -/* - * Allocate space for the signal frame - */ -static inline void * -get_sigframe(struct k_sigaction *ka, struct pt_regs *regs, size_t frame_size) +static void setup_rt_frame(struct pt_regs *regs, struct sigregs *frame, + signed long newsp) { - unsigned long newsp; + struct rt_sigframe *rt_sf = (struct rt_sigframe *)newsp; + /* Handler is *really* a pointer to the function descriptor for + * the signal routine. The first entry in the function + * descriptor is the entry address of signal and the second + * entry is the TOC value we need to use. + */ + struct funct_descr_entry { + unsigned long entry; + unsigned long toc; + }; + + struct funct_descr_entry * funct_desc_ptr; + unsigned long temp_ptr; - /* Default to using normal stack */ - newsp = regs->gpr[1]; + /* Set up preamble frame */ + if (verify_area(VERIFY_WRITE, frame, sizeof(*frame))) + goto badframe; + if (regs->msr & MSR_FP) + giveup_fpu(current); + if (__copy_to_user(&frame->gp_regs, regs, GP_REGS_SIZE) + || __copy_to_user(&frame->fp_regs, current->thread.fpr, + ELF_NFPREG * sizeof(double)) + /* li r0, __NR_rt_sigreturn */ + || __put_user(0x38000000UL + __NR_rt_sigreturn, &frame->tramp[0]) + /* sc */ + || __put_user(0x44000002UL, &frame->tramp[1])) + goto badframe; + flush_icache_range((unsigned long)&frame->tramp[0], + (unsigned long)&frame->tramp[2]); + current->thread.fpscr = 0; /* turn off all fp exceptions */ + + /* Retrieve rt_sigframe from stack and + set up registers for signal handler + */ + newsp -= __SIGNAL_FRAMESIZE; - if (ka->sa.sa_flags & SA_ONSTACK) { - if (! on_sig_stack(regs->gpr[1])) - newsp = (current->sas_ss_sp + current->sas_ss_size); + if (get_user(temp_ptr, &rt_sf->uc.uc_mcontext.handler)) { + goto badframe; } - return (void *)((newsp - frame_size) & -8ul); -} + funct_desc_ptr = (struct funct_descr_entry *)temp_ptr; + + if (put_user(regs->gpr[1], (unsigned long *)newsp) + || get_user(regs->nip, &funct_desc_ptr->entry) + || get_user(regs->gpr[2], &funct_desc_ptr->toc) + || get_user(regs->gpr[3], &rt_sf->uc.uc_mcontext.signal) + || get_user(regs->gpr[4], (unsigned long *)&rt_sf->pinfo) + || get_user(regs->gpr[5], (unsigned long *)&rt_sf->puc)) + goto badframe; -static int -setup_trampoline(unsigned int syscall, unsigned int *tramp) -{ - int i, err = 0; + regs->gpr[1] = newsp; + regs->gpr[6] = (unsigned long)rt_sf; + regs->link = (unsigned long)frame->tramp; - /* addi r1, r1, __SIGNAL_FRAMESIZE # Pop the dummy stackframe */ - err |= __put_user(0x38210000UL | (__SIGNAL_FRAMESIZE & 0xffff), &tramp[0]); - /* li r0, __NR_[rt_]sigreturn| */ - err |= __put_user(0x38000000UL | (syscall & 0xffff), &tramp[1]); - /* sc */ - err |= __put_user(0x44000002UL, &tramp[2]); - - /* Minimal traceback info */ - for (i=TRAMP_TRACEBACK; i < TRAMP_SIZE ;i++) - err |= __put_user(0, &tramp[i]); - - if (!err) - flush_icache_range((unsigned long) &tramp[0], - (unsigned long) &tramp[TRAMP_SIZE]); + return; - return err; +badframe: +#if DEBUG_SIG + printk("badframe in setup_rt_frame, regs=%p frame=%p newsp=%lx\n", + regs, frame, newsp); +#endif + do_exit(SIGSEGV); } /* * Do a signal return; undo the signal stack. */ - -int sys_rt_sigreturn(unsigned long r3, unsigned long r4, unsigned long r5, - unsigned long r6, unsigned long r7, unsigned long r8, - struct pt_regs *regs) -{ - struct ucontext *uc = (struct ucontext *)regs->gpr[1]; +long sys_sigreturn(unsigned long r3, unsigned long r4, unsigned long r5, + unsigned long r6, unsigned long r7, unsigned long r8, + struct pt_regs *regs) +{ + struct sigcontext *sc, sigctx; + struct sigregs *sr; + elf_gregset_t saved_regs; /* an array of ELF_NGREG unsigned longs */ sigset_t set; - stack_t st; - if (verify_area(VERIFY_READ, uc, sizeof(*uc))) + sc = (struct sigcontext *)(regs->gpr[1] + __SIGNAL_FRAMESIZE); + if (copy_from_user(&sigctx, sc, sizeof(sigctx))) goto badframe; - if (__copy_from_user(&set, &uc->uc_sigmask, sizeof(set))) - goto badframe; + set.sig[0] = sigctx.oldmask; +#if _NSIG_WORDS > 1 + set.sig[1] = sigctx._unused[3]; +#endif sigdelsetmask(&set, ~_BLOCKABLE); spin_lock_irq(¤t->sighand->siglock); current->blocked = set; recalc_sigpending(); spin_unlock_irq(¤t->sighand->siglock); + if (regs->msr & MSR_FP) + giveup_fpu(current); - if (restore_sigcontext(regs, NULL, &uc->uc_mcontext)) + /* restore registers */ + sr = (struct sigregs *)sigctx.regs; + if (copy_from_user(saved_regs, &sr->gp_regs, sizeof(sr->gp_regs))) goto badframe; + saved_regs[PT_MSR] = (regs->msr & ~MSR_USERCHANGE) + | (saved_regs[PT_MSR] & MSR_USERCHANGE); + saved_regs[PT_SOFTE] = regs->softe; + memcpy(regs, saved_regs, GP_REGS_SIZE); - if (__copy_from_user(&st, &uc->uc_stack, sizeof(st))) + if (copy_from_user(current->thread.fpr, &sr->fp_regs, + sizeof(sr->fp_regs))) goto badframe; - /* This function sets back the stack flags into - the current task structure. */ - sys_sigaltstack(&st, NULL, 0, 0, 0, 0, regs); return regs->result; badframe: -#if DEBUG_SIG - printk("badframe in sys_rt_sigreturn, regs=%p uc=%p &uc->uc_mcontext=%p\n", - regs, uc, &uc->uc_mcontext); -#endif do_exit(SIGSEGV); -} +} -static void -setup_rt_frame(int signr, struct k_sigaction *ka, siginfo_t *info, - sigset_t *set, struct pt_regs *regs) +/* + * Set up a signal frame. + */ +static void setup_frame(struct pt_regs *regs, struct sigregs *frame, + unsigned long newsp) { + /* Handler is *really* a pointer to the function descriptor for * the signal routine. The first entry in the function * descriptor is the entry address of signal and the second * entry is the TOC value we need to use. */ - func_descr_t *funct_desc_ptr; - struct rt_sigframe *frame; - unsigned long newsp = 0; - int err = 0; - - frame = get_sigframe(ka, regs, sizeof(*frame)); + struct funct_descr_entry { + unsigned long entry; + unsigned long toc; + }; + + struct funct_descr_entry * funct_desc_ptr; + unsigned long temp_ptr; + struct sigcontext *sc = (struct sigcontext *)newsp; + if (verify_area(VERIFY_WRITE, frame, sizeof(*frame))) goto badframe; + if (regs->msr & MSR_FP) + giveup_fpu(current); + if (__copy_to_user(&frame->gp_regs, regs, GP_REGS_SIZE) + || __copy_to_user(&frame->fp_regs, current->thread.fpr, + ELF_NFPREG * sizeof(double)) + /* li r0, __NR_sigreturn */ + || __put_user(0x38000000UL + __NR_sigreturn, &frame->tramp[0]) + /* sc */ + || __put_user(0x44000002UL, &frame->tramp[1])) + goto badframe; + flush_icache_range((unsigned long)&frame->tramp[0], + (unsigned long)&frame->tramp[2]); + current->thread.fpscr = 0; /* turn off all fp exceptions */ - err |= __put_user(&frame->info, &frame->pinfo); - err |= __put_user(&frame->uc, &frame->puc); - err |= copy_siginfo_to_user(&frame->info, info); - if (err) - goto badframe; - - /* Create the ucontext. */ - err |= __put_user(0, &frame->uc.uc_flags); - err |= __put_user(0, &frame->uc.uc_link); - err |= __put_user(current->sas_ss_sp, &frame->uc.uc_stack.ss_sp); - err |= __put_user(sas_ss_flags(regs->gpr[1]), - &frame->uc.uc_stack.ss_flags); - err |= __put_user(current->sas_ss_size, &frame->uc.uc_stack.ss_size); - err |= setup_sigcontext(&frame->uc.uc_mcontext, regs, signr, NULL, - (unsigned long)ka->sa.sa_handler); - err |= __copy_to_user(&frame->uc.uc_sigmask, set, sizeof(*set)); - if (err) - goto badframe; - - /* Set up to return from userspace. */ - err |= setup_trampoline(__NR_rt_sigreturn, &frame->tramp[0]); - if (err) - goto badframe; - - funct_desc_ptr = (func_descr_t *) ka->sa.sa_handler; - - /* Allocate a dummy caller frame for the signal handler. */ - newsp = (unsigned long)frame - __SIGNAL_FRAMESIZE; - err |= put_user(0, (unsigned long *)newsp); - - /* Set up "regs" so we "return" to the signal handler. */ - err |= get_user(regs->nip, &funct_desc_ptr->entry); - regs->link = (unsigned long) &frame->tramp[0]; - regs->gpr[1] = newsp; - err |= get_user(regs->gpr[2], &funct_desc_ptr->toc); - regs->gpr[3] = signr; - if (ka->sa.sa_flags & SA_SIGINFO) { - err |= get_user(regs->gpr[4], (unsigned long *)&frame->pinfo); - err |= get_user(regs->gpr[5], (unsigned long *)&frame->puc); - regs->gpr[6] = (unsigned long) frame; - } else { - regs->gpr[4] = (unsigned long)&frame->uc.uc_mcontext; - } - if (err) + newsp -= __SIGNAL_FRAMESIZE; + if (get_user(temp_ptr, &sc->handler)) + goto badframe; + + funct_desc_ptr = (struct funct_descr_entry *)temp_ptr; + + if (put_user(regs->gpr[1], (unsigned long *)newsp) + || get_user(regs->nip, &funct_desc_ptr ->entry) + || get_user(regs->gpr[2],&funct_desc_ptr->toc) + || get_user(regs->gpr[3], &sc->signal)) goto badframe; + regs->gpr[1] = newsp; + regs->gpr[4] = (unsigned long)sc; + regs->link = (unsigned long)frame->tramp; return; badframe: #if DEBUG_SIG - printk("badframe in setup_rt_frame, regs=%p frame=%p newsp=%lx\n", + printk("badframe in setup_frame, regs=%p frame=%p newsp=%lx\n", regs, frame, newsp); #endif do_exit(SIGSEGV); } - /* * OK, we're invoking a handler */ -static void -handle_signal(unsigned long sig, struct k_sigaction *ka, - siginfo_t *info, sigset_t *oldset, struct pt_regs *regs) +static void handle_signal(unsigned long sig, siginfo_t *info, sigset_t *oldset, + struct pt_regs * regs, unsigned long *newspp, unsigned long frame) { + struct sigcontext *sc; + struct rt_sigframe *rt_sf; + struct k_sigaction *ka = ¤t->sighand->action[sig-1]; + + if (regs->trap == 0x0C00 /* System Call! */ + && ((int)regs->result == -ERESTARTNOHAND || + (int)regs->result == -ERESTART_RESTARTBLOCK || + ((int)regs->result == -ERESTARTSYS && + !(ka->sa.sa_flags & SA_RESTART)))) { + if ((int)regs->result == -ERESTART_RESTARTBLOCK) + current_thread_info()->restart_block.fn + = do_no_restart_syscall; + regs->result = -EINTR; + } + /* Set up Signal Frame */ - setup_rt_frame(sig, ka, info, oldset, regs); + if (ka->sa.sa_flags & SA_SIGINFO) { + /* Put a Real Time Context onto stack */ + *newspp -= sizeof(*rt_sf); + rt_sf = (struct rt_sigframe *)*newspp; + if (verify_area(VERIFY_WRITE, rt_sf, sizeof(*rt_sf))) + goto badframe; + + if (__put_user((unsigned long)ka->sa.sa_handler, + &rt_sf->uc.uc_mcontext.handler) + || __put_user(&rt_sf->info, &rt_sf->pinfo) + || __put_user(&rt_sf->uc, &rt_sf->puc) + /* Put the siginfo */ + || copy_siginfo_to_user(&rt_sf->info, info) + /* Create the ucontext */ + || __put_user(0, &rt_sf->uc.uc_flags) + || __put_user(0, &rt_sf->uc.uc_link) + || __put_user(current->sas_ss_sp, &rt_sf->uc.uc_stack.ss_sp) + || __put_user(sas_ss_flags(regs->gpr[1]), + &rt_sf->uc.uc_stack.ss_flags) + || __put_user(current->sas_ss_size, + &rt_sf->uc.uc_stack.ss_size) + || __copy_to_user(&rt_sf->uc.uc_sigmask, + oldset, sizeof(*oldset)) + /* mcontext.regs points to preamble register frame */ + || __put_user((struct pt_regs *)frame, &rt_sf->uc.uc_mcontext.regs) + || __put_user(sig, &rt_sf->uc.uc_mcontext.signal)) + goto badframe; + } else { + /* Put a sigcontext on the stack */ + *newspp -= sizeof(*sc); + sc = (struct sigcontext *)*newspp; + if (verify_area(VERIFY_WRITE, sc, sizeof(*sc))) + goto badframe; + + if (__put_user((unsigned long)ka->sa.sa_handler, &sc->handler) + || __put_user(oldset->sig[0], &sc->oldmask) +#if _NSIG_WORDS > 1 + || __put_user(oldset->sig[1], &sc->_unused[3]) +#endif + || __put_user((struct pt_regs *)frame, &sc->regs) + || __put_user(sig, &sc->signal)) + goto badframe; + } if (ka->sa.sa_flags & SA_ONESHOT) ka->sa.sa_handler = SIG_DFL; @@ -349,40 +515,14 @@ spin_unlock_irq(¤t->sighand->siglock); } return; -} -static inline void -syscall_restart(struct pt_regs *regs, struct k_sigaction *ka) -{ - switch ((int)regs->result) { - case -ERESTART_RESTARTBLOCK: - current_thread_info()->restart_block.fn = do_no_restart_syscall; - /* fallthrough */ - case -ERESTARTNOHAND: - /* ERESTARTNOHAND means that the syscall should only be - * restarted if there was no handler for the signal, and since - * we only get here if there is a handler, we dont restart. - */ - regs->result = -EINTR; - break; - case -ERESTARTSYS: - /* ERESTARTSYS means to restart the syscall if there is no - * handler or the handler was registered with SA_RESTART - */ - if (!(ka->sa.sa_flags & SA_RESTART)) { - regs->result = -EINTR; - break; - } - /* fallthrough */ - case -ERESTARTNOINTR: - /* ERESTARTNOINTR means that the syscall should be - * called again after the signal handler returns. - */ - regs->gpr[3] = regs->orig_gpr3; - regs->nip -= 4; - regs->result = 0; - break; - } +badframe: +#if DEBUG_SIG + printk("badframe in handle_signal, regs=%p frame=%lx newsp=%lx\n", + regs, frame, *newspp); + printk("sc=%p sig=%d ka=%p info=%p oldset=%p\n", sc, sig, ka, info, oldset); +#endif + do_exit(SIGSEGV); } /* @@ -395,6 +535,8 @@ int do_signal(sigset_t *oldset, struct pt_regs *regs) { siginfo_t info; + struct k_sigaction *ka; + unsigned long frame, newsp; int signr; /* @@ -407,15 +549,20 @@ if (!oldset) oldset = ¤t->blocked; + newsp = frame = 0; + signr = get_signal_to_deliver(&info, regs, NULL); if (signr > 0) { - struct k_sigaction *ka = ¤t->sighand->action[signr-1]; + ka = ¤t->sighand->action[signr-1]; + if ((ka->sa.sa_flags & SA_ONSTACK) + && (!on_sig_stack(regs->gpr[1]))) + newsp = (current->sas_ss_sp + current->sas_ss_size); + else + newsp = regs->gpr[1]; + newsp = frame = newsp - sizeof(struct sigregs); /* Whee! Actually deliver the signal. */ - if (regs->trap == 0x0C00) - syscall_restart(regs, ka); - handle_signal(signr, ka, &info, oldset, regs); - return 1; + handle_signal(signr, &info, oldset, regs, &newsp, frame); } if (regs->trap == 0x0C00) { /* System Call! */ @@ -432,8 +579,13 @@ } } - return 0; -} - - + if (newsp == frame) + return 0; /* no signals delivered */ + /* Invoke correct stack setup routine */ + if (ka->sa.sa_flags & SA_SIGINFO) + setup_rt_frame(regs, (struct sigregs *)frame, newsp); + else + setup_frame(regs, (struct sigregs *)frame, newsp); + return 1; +} diff -Nru a/arch/ppc64/kernel/signal32.c b/arch/ppc64/kernel/signal32.c --- a/arch/ppc64/kernel/signal32.c Fri Jun 13 00:37:27 2003 +++ b/arch/ppc64/kernel/signal32.c Fri Jun 13 00:37:27 2003 @@ -114,40 +114,6 @@ * setup_frame32 */ -/* - * Atomically swap in the new signal mask, and wait for a signal. - */ -long sys32_sigsuspend(old_sigset_t mask, int p2, int p3, int p4, int p6, int p7, - struct pt_regs *regs) -{ - sigset_t saveset; - - mask &= _BLOCKABLE; - spin_lock_irq(¤t->sighand->siglock); - saveset = current->blocked; - siginitset(¤t->blocked, mask); - recalc_sigpending(); - spin_unlock_irq(¤t->sighand->siglock); - - regs->result = -EINTR; - regs->gpr[3] = EINTR; - regs->ccr |= 0x10000000; - while (1) { - current->state = TASK_INTERRUPTIBLE; - schedule(); - if (do_signal32(&saveset, regs)) - /* - * If a signal handler needs to be called, - * do_signal32() has set R3 to the signal number (the - * first argument of the signal handler), so don't - * overwrite that with EINTR ! - * In the other cases, do_signal32() doesn't touch - * R3, so it's still set to -EINTR (see above). - */ - return regs->gpr[3]; - } -} - long sys32_sigaction(int sig, struct old_sigaction32 *act, struct old_sigaction32 *oact) { @@ -826,13 +792,13 @@ while (1) { current->state = TASK_INTERRUPTIBLE; schedule(); - if (do_signal32(&saveset, regs)) + if (do_signal(&saveset, regs)) /* * If a signal handler needs to be called, - * do_signal32() has set R3 to the signal number (the + * do_signal() has set R3 to the signal number (the * first argument of the signal handler), so don't * overwrite that with EINTR ! - * In the other cases, do_signal32() doesn't touch + * In the other cases, do_signal() doesn't touch * R3, so it's still set to -EINTR (see above). */ return regs->gpr[3]; diff -Nru a/arch/ppc64/kernel/smp.c b/arch/ppc64/kernel/smp.c --- a/arch/ppc64/kernel/smp.c Fri Jun 13 00:37:27 2003 +++ b/arch/ppc64/kernel/smp.c Fri Jun 13 00:37:27 2003 @@ -46,9 +46,8 @@ #include #include "open_pic.h" #include -#include -int smp_threads_ready; +int smp_threads_ready = 0; unsigned long cache_decay_ticks; /* initialised so it doesn't end up in bss */ @@ -64,6 +63,18 @@ void smp_call_function_interrupt(void); void smp_message_pass(int target, int msg, unsigned long data, int wait); +void xics_setup_cpu(void); +void xics_cause_IPI(int cpu); + +/* + * XICS only has a single IPI, so encode the messages per CPU + */ +struct xics_ipi_struct { + volatile unsigned long value; +} ____cacheline_aligned; + +struct xics_ipi_struct xics_ipi_message[NR_CPUS] __cacheline_aligned; + #define smp_message_pass(t,m,d,w) smp_ops->message_pass((t),(m),(d),(w)) static inline void set_tb(unsigned int upper, unsigned int lower) @@ -178,7 +189,7 @@ smp_ops->kick_cpu = smp_iSeries_kick_cpu; smp_ops->setup_cpu = smp_iSeries_setup_cpu; #warning fix for iseries - systemcfg->processorCount = smp_iSeries_numProcs(); + naca->processorCount = smp_iSeries_numProcs(); } #endif @@ -342,7 +353,7 @@ smp_ops->probe = smp_xics_probe; } - if (systemcfg->platform == PLATFORM_PSERIES) { + if (naca->platform == PLATFORM_PSERIES) { smp_ops->give_timebase = pSeries_give_timebase; smp_ops->take_timebase = pSeries_take_timebase; } diff -Nru a/arch/ppc64/kernel/sys_ppc32.c b/arch/ppc64/kernel/sys_ppc32.c --- a/arch/ppc64/kernel/sys_ppc32.c Fri Jun 13 00:37:27 2003 +++ b/arch/ppc64/kernel/sys_ppc32.c Fri Jun 13 00:37:27 2003 @@ -1801,7 +1801,7 @@ err = do_sys32_shmctl(first, second, (void *)AA(ptr)); break; default: - err = -ENOSYS; + err = -EINVAL; break; } return err; diff -Nru a/arch/ppc64/kernel/syscalls.c b/arch/ppc64/kernel/syscalls.c --- a/arch/ppc64/kernel/syscalls.c Fri Jun 13 00:37:27 2003 +++ b/arch/ppc64/kernel/syscalls.c Fri Jun 13 00:37:27 2003 @@ -68,7 +68,7 @@ version = call >> 16; /* hack for backward compatibility */ call &= 0xffff; - ret = -ENOSYS; + ret = -EINVAL; switch (call) { case SEMOP: ret = sys_semop (first, (struct sembuf *)ptr, second); diff -Nru a/arch/ppc64/kernel/traps.c b/arch/ppc64/kernel/traps.c --- a/arch/ppc64/kernel/traps.c Fri Jun 13 00:37:27 2003 +++ b/arch/ppc64/kernel/traps.c Fri Jun 13 00:37:27 2003 @@ -55,12 +55,14 @@ * Trap & Exception support */ +/* Should we panic on bad kernel exceptions or try to recover */ +#undef PANIC_ON_ERROR + static spinlock_t die_lock = SPIN_LOCK_UNLOCKED; void die(const char *str, struct pt_regs *regs, long err) { static int die_counter; - console_verbose(); spin_lock_irq(&die_lock); bust_spinlocks(1); @@ -69,16 +71,11 @@ bust_spinlocks(0); spin_unlock_irq(&die_lock); - if (in_interrupt()) - panic("Fatal exception in interrupt"); - - if (panic_on_oops) { - printk(KERN_EMERG "Fatal exception: panic in 5 seconds\n"); - set_current_state(TASK_UNINTERRUPTIBLE); - schedule_timeout(5 * HZ); - panic("Fatal exception"); - } +#ifdef PANIC_ON_ERROR + panic(str); +#else do_exit(SIGSEGV); +#endif } static void @@ -142,13 +139,15 @@ #ifdef CONFIG_DEBUG_KERNEL if (debugger) debugger(regs); - else #endif - panic("System Reset"); +#ifdef PANIC_ON_ERROR + panic("System Reset"); +#else /* Must die if the interrupt is not recoverable */ if (!(regs->msr & MSR_RI)) panic("Unrecoverable System Reset"); +#endif /* What should we do here? We could issue a shutdown or hard reset. */ } @@ -344,14 +343,6 @@ info.si_addr = (void *)regs->nip; _exception(SIGILL, &info, regs); } -} - - void -KernelFPUnavailableException(struct pt_regs *regs) -{ - printk("Illegal floating point used in kernel (task=0x%016lx, pc=0x%016lx, trap=0x%08x)\n", - current, regs->nip, regs->trap); - panic("Unrecoverable FP Unavailable Exception in Kernel"); } void diff -Nru a/arch/ppc64/kernel/udbg.c b/arch/ppc64/kernel/udbg.c --- a/arch/ppc64/kernel/udbg.c Fri Jun 13 00:37:27 2003 +++ b/arch/ppc64/kernel/udbg.c Fri Jun 13 00:37:27 2003 @@ -176,7 +176,7 @@ void udbg_printSP(const char *s) { - if (systemcfg->platform == PLATFORM_PSERIES) { + if (naca->platform == PLATFORM_PSERIES) { unsigned long sp; asm("mr %0,1" : "=r" (sp) :); if (s) diff -Nru a/arch/ppc64/kernel/xics.c b/arch/ppc64/kernel/xics.c --- a/arch/ppc64/kernel/xics.c Fri Jun 13 00:37:27 2003 +++ b/arch/ppc64/kernel/xics.c Fri Jun 13 00:37:27 2003 @@ -1,5 +1,5 @@ /* - * arch/ppc64/kernel/xics.c + * arch/ppc/kernel/xics.c * * Copyright 2000 IBM Corporation. * @@ -22,11 +22,10 @@ #include #include #include +#include "i8259.h" #include #include -#include - -#include "i8259.h" +#include void xics_enable_irq(u_int irq); void xics_disable_irq(u_int irq); @@ -62,39 +61,33 @@ /* Want a priority other than 0. Various HW issues require this. */ #define DEFAULT_PRIORITY 5 -/* - * Mark IPIs as higher priority so we can take them inside interrupts that - * arent marked SA_INTERRUPT - */ -#define IPI_PRIORITY 4 - struct xics_ipl { union { - u32 word; - u8 bytes[4]; + u32 word; + u8 bytes[4]; } xirr_poll; union { u32 word; - u8 bytes[4]; + u8 bytes[4]; } xirr; - u32 dummy; + u32 dummy; union { - u32 word; - u8 bytes[4]; + u32 word; + u8 bytes[4]; } qirr; }; -static struct xics_ipl *xics_per_cpu[NR_CPUS]; +struct xics_info { + volatile struct xics_ipl * per_cpu[NR_CPUS]; +}; -static int xics_irq_8259_cascade = 0; -static int xics_irq_8259_cascade_real = 0; -static unsigned int default_server = 0xFF; -static unsigned int default_distrib_server = 0; +struct xics_info xics_info; -/* - * XICS only has a single IPI, so encode the messages per CPU - */ -struct xics_ipi_struct xics_ipi_message[NR_CPUS] __cacheline_aligned; +unsigned long long intr_base = 0; +int xics_irq_8259_cascade = 0; +int xics_irq_8259_cascade_real = 0; +unsigned int default_server = 0xFF; +unsigned int default_distrib_server = 0; /* RTAS service tokens */ int ibm_get_xive; @@ -102,6 +95,11 @@ int ibm_int_on; int ibm_int_off; +struct xics_interrupt_node { + unsigned long long addr; + unsigned long long size; +} inodes[NR_CPUS*2]; + typedef struct { int (*xirr_info_get)(int cpu); void (*xirr_info_set)(int cpu, int val); @@ -110,26 +108,24 @@ } xics_ops; -/* SMP */ - static int pSeries_xirr_info_get(int n_cpu) { - return xics_per_cpu[n_cpu]->xirr.word; + return (xics_info.per_cpu[n_cpu]->xirr.word); } static void pSeries_xirr_info_set(int n_cpu, int value) { - xics_per_cpu[n_cpu]->xirr.word = value; + xics_info.per_cpu[n_cpu]->xirr.word = value; } static void pSeries_cppr_info(int n_cpu, u8 value) { - xics_per_cpu[n_cpu]->xirr.bytes[0] = value; + xics_info.per_cpu[n_cpu]->xirr.bytes[0] = value; } -static void pSeries_qirr_info(int n_cpu, u8 value) +static void pSeries_qirr_info(int n_cpu , u8 value) { - xics_per_cpu[n_cpu]->qirr.bytes[0] = value; + xics_info.per_cpu[n_cpu]->qirr.bytes[0] = value; } static xics_ops pSeries_ops = { @@ -140,174 +136,113 @@ }; static xics_ops *ops = &pSeries_ops; +extern xics_ops pSeriesLP_ops; -/* LPAR */ - -static inline long plpar_eoi(unsigned long xirr) +void +xics_enable_irq( + u_int virq + ) { - return plpar_hcall_norets(H_EOI, xirr); -} - -static inline long plpar_cppr(unsigned long cppr) -{ - return plpar_hcall_norets(H_CPPR, cppr); -} - -static inline long plpar_ipi(unsigned long servernum, unsigned long mfrr) -{ - return plpar_hcall_norets(H_IPI, servernum, mfrr); -} - -static inline long plpar_xirr(unsigned long *xirr_ret) -{ - unsigned long dummy; - return plpar_hcall(H_XIRR, 0, 0, 0, 0, xirr_ret, &dummy, &dummy); -} - -static int pSeriesLP_xirr_info_get(int n_cpu) -{ - unsigned long lpar_rc; - unsigned long return_value; - - lpar_rc = plpar_xirr(&return_value); - if (lpar_rc != H_Success) - panic(" bad return code xirr - rc = %lx \n", lpar_rc); - return (int)return_value; -} - -static void pSeriesLP_xirr_info_set(int n_cpu, int value) -{ - unsigned long lpar_rc; - unsigned long val64 = value & 0xffffffff; - - lpar_rc = plpar_eoi(val64); - if (lpar_rc != H_Success) - panic("bad return code EOI - rc = %ld, value=%lx\n", lpar_rc, - val64); -} - -static void pSeriesLP_cppr_info(int n_cpu, u8 value) -{ - unsigned long lpar_rc; - - lpar_rc = plpar_cppr(value); - if (lpar_rc != H_Success) - panic("bad return code cppr - rc = %lx\n", lpar_rc); -} - -static void pSeriesLP_qirr_info(int n_cpu , u8 value) -{ - unsigned long lpar_rc; - - lpar_rc = plpar_ipi(n_cpu, value); - if (lpar_rc != H_Success) - panic("bad return code qirr - rc = %lx\n", lpar_rc); -} - -xics_ops pSeriesLP_ops = { - pSeriesLP_xirr_info_get, - pSeriesLP_xirr_info_set, - pSeriesLP_cppr_info, - pSeriesLP_qirr_info -}; - -void xics_enable_irq(u_int virq) -{ - u_int irq; - long call_status; - unsigned int server; + u_int irq; + unsigned long status; + long call_status; virq -= XICS_IRQ_OFFSET; irq = virt_irq_to_real(virq); if (irq == XICS_IPI) return; - #ifdef CONFIG_IRQ_ALL_CPUS - if (smp_threads_ready) - server = default_distrib_server; - else - server = default_server; + call_status = rtas_call(ibm_set_xive, 3, 1, (unsigned long*)&status, + irq, smp_threads_ready ? default_distrib_server : default_server, DEFAULT_PRIORITY); #else - server = default_server; + call_status = rtas_call(ibm_set_xive, 3, 1, (unsigned long*)&status, + irq, default_server, DEFAULT_PRIORITY); #endif - - call_status = rtas_call(ibm_set_xive, 3, 1, NULL, irq, server, - DEFAULT_PRIORITY); - if (call_status != 0) { - printk("xics_enable_irq: irq=%x: ibm_set_xive returned %lx\n", - irq, call_status); + if( call_status != 0 ) { + printk("xics_enable_irq: irq=%x: rtas_call failed; retn=%lx, status=%lx\n", + irq, call_status, status); return; } - /* Now unmask the interrupt (often a no-op) */ - call_status = rtas_call(ibm_int_on, 1, 1, NULL, irq); - if (call_status != 0) { - printk("xics_enable_irq: irq=%x: ibm_int_on returned %lx\n", + call_status = rtas_call(ibm_int_on, 1, 1, (unsigned long*)&status, + irq); + if( call_status != 0 ) { + printk("xics_disable_irq on: irq=%x: rtas_call failed, retn=%lx\n", irq, call_status); return; } } -void xics_disable_irq(u_int virq) -{ - u_int irq; - long call_status; +void +xics_disable_irq( + u_int virq + ) +{ + u_int irq; + unsigned long status; + long call_status; virq -= XICS_IRQ_OFFSET; irq = virt_irq_to_real(virq); - if (irq == XICS_IPI) - return; - - call_status = rtas_call(ibm_int_off, 1, 1, NULL, irq); - if (call_status != 0) { - printk("xics_disable_irq: irq=%x: ibm_int_off returned %lx\n", + call_status = rtas_call(ibm_int_off, 1, 1, (unsigned long*)&status, + irq); + if( call_status != 0 ) { + printk("xics_disable_irq: irq=%x: rtas_call failed, retn=%lx\n", irq, call_status); return; } } -void xics_end_irq(u_int irq) +void +xics_end_irq( + u_int irq + ) { int cpu = smp_processor_id(); + ops->cppr_info(cpu, 0); /* actually the value overwritten by ack */ + iosync(); + ops->xirr_info_set(cpu, ((0xff<<24) | (virt_irq_to_real(irq-XICS_IRQ_OFFSET)))); iosync(); - ops->xirr_info_set(cpu, ((0xff<<24) | - (virt_irq_to_real(irq-XICS_IRQ_OFFSET)))); } -void xics_mask_and_ack_irq(u_int irq) +void +xics_mask_and_ack_irq(u_int irq) { int cpu = smp_processor_id(); - if (irq < XICS_IRQ_OFFSET) { + if( irq < XICS_IRQ_OFFSET ) { i8259_pic.ack(irq); iosync(); - ops->xirr_info_set(cpu, ((0xff<<24) | - xics_irq_8259_cascade_real)); + ops->xirr_info_set(cpu, ((0xff<<24) | xics_irq_8259_cascade_real)); + iosync(); + } + else { + ops->cppr_info(cpu, 0xff); iosync(); } } -int xics_get_irq(struct pt_regs *regs) +int +xics_get_irq(struct pt_regs *regs) { - u_int cpu = smp_processor_id(); - u_int vec; + u_int cpu = smp_processor_id(); + u_int vec; int irq; vec = ops->xirr_info_get(cpu); /* (vec >> 24) == old priority */ vec &= 0x00ffffff; - /* for sanity, this had better be < NR_IRQS - 16 */ - if (vec == xics_irq_8259_cascade_real) { + if( vec == xics_irq_8259_cascade_real ) { irq = i8259_irq(cpu); - if (irq == -1) { + if(irq == -1) { /* Spurious cascaded interrupt. Still must ack xics */ xics_end_irq(XICS_IRQ_OFFSET + xics_irq_8259_cascade); irq = -1; } - } else if (vec == XICS_IRQ_SPURIOUS) { + } else if( vec == XICS_IRQ_SPURIOUS ) { irq = -1; } else { irq = real_irq_to_virt(vec) + XICS_IRQ_OFFSET; @@ -315,49 +250,45 @@ return irq; } -#ifdef CONFIG_SMP +struct xics_ipi_struct { + volatile unsigned long value; +} ____cacheline_aligned; extern struct xics_ipi_struct xics_ipi_message[NR_CPUS] __cacheline_aligned; -irqreturn_t xics_ipi_action(int irq, void *dev_id, struct pt_regs *regs) +#ifdef CONFIG_SMP +void xics_ipi_action(int irq, void *dev_id, struct pt_regs *regs) { int cpu = smp_processor_id(); - int handled = 0; ops->qirr_info(cpu, 0xff); while (xics_ipi_message[cpu].value) { - handled = 1; - if (test_and_clear_bit(PPC_MSG_CALL_FUNCTION, - &xics_ipi_message[cpu].value)) { + if (test_and_clear_bit(PPC_MSG_CALL_FUNCTION, &xics_ipi_message[cpu].value)) { mb(); smp_message_recv(PPC_MSG_CALL_FUNCTION, regs); } - if (test_and_clear_bit(PPC_MSG_RESCHEDULE, - &xics_ipi_message[cpu].value)) { + if (test_and_clear_bit(PPC_MSG_RESCHEDULE, &xics_ipi_message[cpu].value)) { mb(); smp_message_recv(PPC_MSG_RESCHEDULE, regs); } #if 0 - if (test_and_clear_bit(PPC_MSG_MIGRATE_TASK, - &xics_ipi_message[cpu].value)) { + if (test_and_clear_bit(PPC_MSG_MIGRATE_TASK, &xics_ipi_message[cpu].value)) { mb(); smp_message_recv(PPC_MSG_MIGRATE_TASK, regs); } #endif #ifdef CONFIG_XMON - if (test_and_clear_bit(PPC_MSG_XMON_BREAK, - &xics_ipi_message[cpu].value)) { + if (test_and_clear_bit(PPC_MSG_XMON_BREAK, &xics_ipi_message[cpu].value)) { mb(); smp_message_recv(PPC_MSG_XMON_BREAK, regs); } #endif } - return IRQ_RETVAL(handled); } void xics_cause_IPI(int cpu) { - ops->qirr_info(cpu, IPI_PRIORITY); + ops->qirr_info(cpu,0) ; } void xics_setup_cpu(void) @@ -367,20 +298,15 @@ ops->cppr_info(cpu, 0xff); iosync(); } - #endif /* CONFIG_SMP */ -void xics_init_IRQ(void) +void +xics_init_IRQ( void ) { int i; unsigned long intr_size = 0; struct device_node *np; uint *ireg, ilen, indx=0; - unsigned long intr_base = 0; - struct xics_interrupt_node { - unsigned long long addr; - unsigned long long size; - } inodes[NR_CPUS*2]; ppc64_boot_msg(0x20, "XICS Init"); @@ -460,24 +386,23 @@ xics_irq_8259_cascade = virt_irq_create_mapping(xics_irq_8259_cascade_real); } - if (systemcfg->platform == PLATFORM_PSERIES) { + if (naca->platform == PLATFORM_PSERIES) { #ifdef CONFIG_SMP for (i = 0; i < NR_CPUS; ++i) { if (!cpu_possible(i)) continue; - xics_per_cpu[i] = __ioremap((ulong)inodes[i].addr, - (ulong)inodes[i].size, - _PAGE_NO_CACHE); + xics_info.per_cpu[i] = + __ioremap((ulong)inodes[i].addr, + (ulong)inodes[i].size, _PAGE_NO_CACHE); } #else - xics_per_cpu[0] = __ioremap((ulong)intr_base, intr_size, - _PAGE_NO_CACHE); + xics_info.per_cpu[0] = __ioremap((ulong)intr_base, intr_size, _PAGE_NO_CACHE); #endif /* CONFIG_SMP */ #ifdef CONFIG_PPC_PSERIES /* actually iSeries does not use any of xics...but it has link dependencies * for now, except this new one... */ - } else if (systemcfg->platform == PLATFORM_PSERIES_LPAR) { + } else if (naca->platform == PLATFORM_PSERIES_LPAR) { ops = &pSeriesLP_ops; #endif } @@ -492,8 +417,8 @@ ops->cppr_info(boot_cpuid, 0xff); iosync(); if (xics_irq_8259_cascade != -1) { - if (request_irq(xics_irq_8259_cascade + XICS_IRQ_OFFSET, - no_action, 0, "8259 cascade", 0)) + if (request_irq(xics_irq_8259_cascade + XICS_IRQ_OFFSET, no_action, + 0, "8259 cascade", 0)) printk(KERN_ERR "xics_init_IRQ: couldn't get 8259 cascade\n"); i8259_init(); } diff -Nru a/arch/ppc64/mm/fault.c b/arch/ppc64/mm/fault.c --- a/arch/ppc64/mm/fault.c Fri Jun 13 00:37:27 2003 +++ b/arch/ppc64/mm/fault.c Fri Jun 13 00:37:27 2003 @@ -75,8 +75,8 @@ } #endif - /* On a kernel SLB miss we can only check for a valid exception entry */ - if (!user_mode(regs) && (regs->trap == 0x380)) { + /* On an SLB miss we can only check for a valid exception entry */ + if (regs->trap == 0x380) { bad_page_fault(regs, address, SIGSEGV); return; } diff -Nru a/arch/ppc64/mm/init.c b/arch/ppc64/mm/init.c --- a/arch/ppc64/mm/init.c Fri Jun 13 00:37:27 2003 +++ b/arch/ppc64/mm/init.c Fri Jun 13 00:37:27 2003 @@ -69,6 +69,8 @@ int mem_init_done; unsigned long ioremap_bot = IMALLOC_BASE; +static int boot_mapsize; + extern pgd_t swapper_pg_dir[]; extern char __init_begin, __init_end; extern char _start[], _end[]; @@ -452,7 +454,6 @@ unsigned long i; unsigned long start, bootmap_pages; unsigned long total_pages = lmb_end_of_DRAM() >> PAGE_SHIFT; - int boot_mapsize; /* * Find an area to use for the bootmem bitmap. Calculate the size of @@ -531,7 +532,7 @@ int nid; for (nid = 0; nid < numnodes; nid++) { - if (node_data[nid].node_size != 0) { + if (numa_node_exists[nid]) { printk("freeing bootmem node %x\n", nid); totalram_pages += free_all_bootmem_node(NODE_DATA(nid)); diff -Nru a/arch/ppc64/mm/numa.c b/arch/ppc64/mm/numa.c --- a/arch/ppc64/mm/numa.c Fri Jun 13 00:37:27 2003 +++ b/arch/ppc64/mm/numa.c Fri Jun 13 00:37:27 2003 @@ -24,18 +24,11 @@ int numa_cpu_lookup_table[NR_CPUS] = { [ 0 ... (NR_CPUS - 1)] = -1}; int numa_memory_lookup_table[MAX_MEMORY >> MEMORY_INCREMENT_SHIFT] = { [ 0 ... ((MAX_MEMORY >> MEMORY_INCREMENT_SHIFT) - 1)] = -1}; -unsigned long numa_cpumask_lookup_table[MAX_NUMNODES]; +int numa_node_exists[MAX_NUMNODES]; struct pglist_data node_data[MAX_NUMNODES]; bootmem_data_t plat_node_bdata[MAX_NUMNODES]; -static inline void map_cpu_to_node(int cpu, int node) -{ - dbg("cpu %d maps to domain %d\n", cpu, node); - numa_cpu_lookup_table[cpu] = node; - numa_cpumask_lookup_table[node] |= 1UL << cpu; -} - static int __init parse_numa_properties(void) { struct device_node *cpu; @@ -95,7 +88,9 @@ if (max_domain < numa_domain) max_domain = numa_domain; - map_cpu_to_node(cpu_nr, numa_domain); + numa_cpu_lookup_table[cpu_nr] = numa_domain; + + dbg("cpu %d maps to domain %d\n", cpu_nr, numa_domain); } for (memory = find_type_devices("memory"); memory; @@ -140,7 +135,7 @@ /* FIXME */ if (numa_domain == 0xffff) { - dbg("memory has no numa doman\n"); + dbg("cpu has no numa doman\n"); numa_domain = 0; } @@ -150,8 +145,7 @@ if (max_domain < numa_domain) max_domain = numa_domain; - node_data[numa_domain].node_start_pfn = start / PAGE_SIZE; - node_data[numa_domain].node_size = size / PAGE_SIZE; + numa_node_exists[numa_domain] = 1; for (i = start ; i < (start+size); i += MEMORY_INCREMENT) numa_memory_lookup_table[i >> MEMORY_INCREMENT_SHIFT] = @@ -182,17 +176,27 @@ BUG(); for (nid = 0; nid < numnodes; nid++) { + unsigned long start, end; unsigned long start_paddr, end_paddr; int i; unsigned long bootmem_paddr; unsigned long bootmap_pages; - if (node_data[nid].node_size == 0) + if (!numa_node_exists[nid]) continue; - start_paddr = node_data[nid].node_start_pfn * PAGE_SIZE; - end_paddr = start_paddr + - (node_data[nid].node_size * PAGE_SIZE); + /* Find start and end of this zone */ + start = 0; + while (numa_memory_lookup_table[start] != nid) + start++; + + end = (MAX_MEMORY >> MEMORY_INCREMENT_SHIFT) - 1; + while (numa_memory_lookup_table[end] != nid) + end--; + end++; + + start_paddr = start << MEMORY_INCREMENT_SHIFT; + end_paddr = end << MEMORY_INCREMENT_SHIFT; dbg("node %d\n", nid); dbg("start_paddr = %lx\n", start_paddr); @@ -274,7 +278,7 @@ unsigned long start_pfn; unsigned long end_pfn; - if (node_data[nid].node_size == 0) + if (!numa_node_exists[nid]) continue; start_pfn = plat_node_bdata[nid].node_boot_start >> PAGE_SHIFT; diff -Nru a/arch/ppc64/xmon/xmon.c b/arch/ppc64/xmon/xmon.c --- a/arch/ppc64/xmon/xmon.c Fri Jun 13 00:37:27 2003 +++ b/arch/ppc64/xmon/xmon.c Fri Jun 13 00:37:27 2003 @@ -453,7 +453,7 @@ int i; struct bpt *bp; - if (systemcfg->platform != PLATFORM_PSERIES) + if (naca->platform != PLATFORM_PSERIES) return; bp = bpts; for (i = 0; i < NBPTS; ++i, ++bp) { @@ -469,10 +469,12 @@ } } - if (cpu_has_dabr() && dabr.enabled) - set_dabr(dabr.address); - if (cpu_has_iabr() && iabr.enabled) - set_iabr(iabr.address); + if (!__is_processor(PV_POWER4) && !__is_processor(PV_POWER4p)) { + if (dabr.enabled) + set_dabr(dabr.address); + if (iabr.enabled) + set_iabr(iabr.address); + } } static void @@ -482,13 +484,12 @@ struct bpt *bp; unsigned instr; - if (systemcfg->platform != PLATFORM_PSERIES) + if (naca->platform != PLATFORM_PSERIES) return; - - if (cpu_has_dabr()) + if (!__is_processor(PV_POWER4) && !__is_processor(PV_POWER4p)) { set_dabr(0); - if (cpu_has_iabr()) set_iabr(0); + } bp = bpts; for (i = 0; i < NBPTS; ++i, ++bp) { @@ -777,8 +778,8 @@ cmd = inchar(); switch (cmd) { case 'd': /* bd - hardware data breakpoint */ - if (cpu_has_dabr()) { - printf("Not implemented on this cpu\n"); + if (__is_processor(PV_POWER4) || __is_processor(PV_POWER4p)) { + printf("Not implemented on POWER4\n"); break; } mode = 7; @@ -797,7 +798,7 @@ dabr.address = (dabr.address & ~7) | mode; break; case 'i': /* bi - hardware instr breakpoint */ - if (cpu_has_iabr()) { + if (__is_processor(PV_POWER4) || __is_processor(PV_POWER4p)) { printf("Not implemented on POWER4\n"); break; } diff -Nru a/include/asm-ppc64/io.h b/include/asm-ppc64/io.h --- a/include/asm-ppc64/io.h Fri Jun 13 00:37:27 2003 +++ b/include/asm-ppc64/io.h Fri Jun 13 00:37:27 2003 @@ -107,6 +107,7 @@ #define IO_SPACE_LIMIT ~(0UL) +#define MEM_SPACE_LIMIT ~(0UL) #ifdef __KERNEL__ diff -Nru a/include/asm-ppc64/mmu.h b/include/asm-ppc64/mmu.h --- a/include/asm-ppc64/mmu.h Fri Jun 13 00:37:27 2003 +++ b/include/asm-ppc64/mmu.h Fri Jun 13 00:37:27 2003 @@ -221,13 +221,6 @@ #endif /* __ASSEMBLY__ */ -/* - * Location of cpu0's segment table - */ -#define STAB0_PAGE 0x9 -#define STAB0_PHYS_ADDR (STAB0_PAGE< -#include - -#ifndef __ASSEMBLY__ struct naca_struct { - /*================================================================== - * Cache line 1: 0x0000 - 0x007F - * Kernel only data - undefined for user space - *================================================================== - */ - void *xItVpdAreas; /* VPD Data 0x00 */ - void *xRamDisk; /* iSeries ramdisk 0x08 */ - u64 xRamDiskSize; /* In pages 0x10 */ - struct paca_struct *paca; /* Ptr to an array of pacas 0x18 */ - u64 debug_switch; /* Debug print control 0x20 */ - u64 banner; /* Ptr to banner string 0x28 */ - u64 log; /* Ptr to log buffer 0x30 */ - u64 serialPortAddr; /* Phy addr of serial port 0x38 */ - u64 interrupt_controller; /* Type of int controller 0x40 */ - u64 slb_size; /* SLB size in entries 0x48 */ - u64 pftSize; /* Log 2 of page table size 0x50 */ - void *systemcfg; /* Pointer to systemcfg data 0x58 */ - u32 dCacheL1LogLineSize; /* L1 d-cache line size Log2 0x60 */ - u32 dCacheL1LinesPerPage; /* L1 d-cache lines / page 0x64 */ - u32 iCacheL1LogLineSize; /* L1 i-cache line size Log2 0x68 */ - u32 iCacheL1LinesPerPage; /* L1 i-cache lines / page 0x6c */ - u64 resv0[2]; /* Reserved 0x70 - 0x7F */ + void *xItVpdAreas; + void *xRamDisk; + u64 xRamDiskSize; /* In pages */ + struct paca_struct *paca; /* Ptr to an array of pacas */ + u64 debug_switch; /* Bits to control debug printing */ + u16 dCacheL1LineSize; /* Line size of L1 DCache in bytes */ + u16 dCacheL1LogLineSize; /* Log-2 of DCache line size */ + u16 dCacheL1LinesPerPage; /* DCache lines per page */ + u16 iCacheL1LineSize; /* Line size of L1 ICache in bytes */ + u16 iCacheL1LogLineSize; /* Log-2 of ICache line size */ + u16 iCacheL1LinesPerPage; /* ICache lines per page */ + u16 slb_size; /* SLB size in entries */ + u64 physicalMemorySize; /* Size of real memory in bytes */ + u64 pftSize; /* Log base 2 of page table size */ + u64 serialPortAddr; /* Phyical address of serial port */ + u8 interrupt_controller; /* Type of interrupt controller */ + u8 resv0; /* Type of interrupt controller */ + u16 platform; /* Platform flags */ + u8 resv1[12]; /* Padding */ }; extern struct naca_struct *naca; - -#endif /* __ASSEMBLY__ */ - -#define NACA_PAGE 0x4 -#define NACA_PHYS_ADDR (NACA_PAGE<> SID_SHIFT) & SID_MASK) -/* align addr on a size boundary - adjust address up/down if needed */ -#define _ALIGN_UP(addr,size) (((addr)+((size)-1))&(~((size)-1))) -#define _ALIGN_DOWN(addr,size) ((addr)&(~((size)-1))) - -/* align addr on a size boundary - adjust address up if needed */ -#define _ALIGN(addr,size) _ALIGN_UP(addr,size) - -/* to align the pointer to the (next) double word boundary */ -#define DOUBLEWORD_ALIGN(addr) _ALIGN(addr,sizeof(unsigned long)) - -/* to align the pointer to the (next) page boundary */ -#define PAGE_ALIGN(addr) _ALIGN(addr, PAGE_SIZE) - #ifdef __KERNEL__ #ifndef __ASSEMBLY__ #include @@ -54,7 +37,7 @@ { unsigned long lines, line_size; - line_size = systemcfg->dCacheL1LineSize; + line_size = naca->dCacheL1LineSize; lines = naca->dCacheL1LinesPerPage; __asm__ __volatile__( @@ -130,6 +113,19 @@ #define __pa(x) ((unsigned long)(x)-PAGE_OFFSET) #endif /* __ASSEMBLY__ */ + +/* align addr on a size boundary - adjust address up/down if needed */ +#define _ALIGN_UP(addr,size) (((addr)+((size)-1))&(~((size)-1))) +#define _ALIGN_DOWN(addr,size) ((addr)&(~((size)-1))) + +/* align addr on a size boundary - adjust address up if needed */ +#define _ALIGN(addr,size) _ALIGN_UP(addr,size) + +/* to align the pointer to the (next) double word boundary */ +#define DOUBLEWORD_ALIGN(addr) _ALIGN(addr,sizeof(unsigned long)) + +/* to align the pointer to the (next) page boundary */ +#define PAGE_ALIGN(addr) _ALIGN(addr, PAGE_SIZE) #ifdef MODULE #define __page_aligned __attribute__((__aligned__(PAGE_SIZE))) diff -Nru a/include/asm-ppc64/pgtable.h b/include/asm-ppc64/pgtable.h --- a/include/asm-ppc64/pgtable.h Fri Jun 13 00:37:27 2003 +++ b/include/asm-ppc64/pgtable.h Fri Jun 13 00:37:27 2003 @@ -303,11 +303,6 @@ pte_update(ptep, 0, _PAGE_DIRTY); } -/* - * Macro to mark a page protection value as "uncacheable". - */ -#define pgprot_noncached(prot) (__pgprot(pgprot_val(prot) | _PAGE_NO_CACHE | _PAGE_GUARDED)) - #define pte_same(A,B) (((pte_val(A) ^ pte_val(B)) & ~_PAGE_HPTEFLAGS) == 0) /* diff -Nru a/include/asm-ppc64/proc_fs.h b/include/asm-ppc64/proc_fs.h --- a/include/asm-ppc64/proc_fs.h Fri Jun 13 00:37:27 2003 +++ b/include/asm-ppc64/proc_fs.h Fri Jun 13 00:37:27 2003 @@ -25,14 +25,9 @@ #include -struct proc_ppc64_t { - struct proc_dir_entry *root; - struct proc_dir_entry *naca; - struct proc_dir_entry *paca; - struct proc_dir_entry *systemcfg; - struct proc_dir_entry *rtas; -}; +void pmc_proc_init(struct proc_dir_entry *iSeries_proc); +void proc_ppc64_init(void); -extern struct proc_ppc64_t proc_ppc64; +#include -#endif /* _PPC64_PROC_FS_H */ +#endif diff -Nru a/include/asm-ppc64/processor.h b/include/asm-ppc64/processor.h --- a/include/asm-ppc64/processor.h Fri Jun 13 00:37:27 2003 +++ b/include/asm-ppc64/processor.h Fri Jun 13 00:37:27 2003 @@ -469,6 +469,8 @@ #define IOCR_SPC 0x00000001 +/* Processor Version Register */ + /* Processor Version Register (PVR) field extraction */ #define PVR_VER(pvr) (((pvr) >> 16) & 0xFFFF) /* Version field */ @@ -593,8 +595,6 @@ asm volatile("mfasr %0" : "=r" (rval)); rval;}) #ifndef __ASSEMBLY__ -extern unsigned long *_get_SP(void); - extern int have_of; struct task_struct; @@ -654,10 +654,8 @@ struct pt_regs *regs; /* Pointer to saved register state */ mm_segment_t fs; /* for get_fs() validation */ double fpr[32]; /* Complete floating point set */ - unsigned long fpscr; /* Floating point status (plus pad) */ - unsigned long fpexc_mode; /* Floating-point exception mode */ - unsigned long saved_msr; /* Save MSR across signal handlers */ - unsigned long saved_softe; /* Ditto for Soft Enable/Disable */ + unsigned long fpscr; /* Floating point status */ + unsigned int fpexc_mode; /* Floating-point exception mode */ }; #define INIT_SP (sizeof(init_stack) + (unsigned long) &init_stack) @@ -704,7 +702,7 @@ return ((msr_bits & MSR_FE0) >> 10) | ((msr_bits & MSR_FE1) >> 8); } -static inline unsigned long __pack_fe01(unsigned int fpmode) +static inline unsigned int __pack_fe01(unsigned int fpmode) { return ((fpmode << 10) & MSR_FE0) | ((fpmode << 8) & MSR_FE1); } @@ -741,15 +739,6 @@ #define cpu_has_noexecute() (processor_type() == PV_POWER4 || \ processor_type() == PV_POWER4p) - -/* XXX we have to call HV to set when in LPAR */ -#define cpu_has_dabr() (1) - -#define cpu_has_iabr() (processor_type() != PV_POWER4 && \ - processor_type() != PV_POWER4p) - -#define cpu_alignexc_sets_dsisr() (processor_type() != PV_POWER4 && \ - processor_type() != PV_POWER4p) #endif /* ASSEMBLY */ diff -Nru a/include/asm-ppc64/ptrace.h b/include/asm-ppc64/ptrace.h --- a/include/asm-ppc64/ptrace.h Fri Jun 13 00:37:27 2003 +++ b/include/asm-ppc64/ptrace.h Fri Jun 13 00:37:27 2003 @@ -64,8 +64,9 @@ #define STACK_FRAME_OVERHEAD 112 /* size of minimum stack frame */ -/* Size of dummy stack frame allocated when calling signal handler. */ -#define __SIGNAL_FRAMESIZE 128 +/* Size of stack frame allocated when calling signal handler. */ +/* FIXME: What should this be on 64-bit kernel (64 for 32-bit) */ +#define __SIGNAL_FRAMESIZE 64 #define __SIGNAL_FRAMESIZE32 64 #define instruction_pointer(regs) ((regs)->nip) diff -Nru a/include/asm-ppc64/rtas.h b/include/asm-ppc64/rtas.h --- a/include/asm-ppc64/rtas.h Fri Jun 13 00:37:27 2003 +++ b/include/asm-ppc64/rtas.h Fri Jun 13 00:37:27 2003 @@ -166,6 +166,8 @@ extern void rtas_power_off(void); extern void rtas_halt(void); +extern struct proc_dir_entry *rtas_proc_dir; + /* Some RTAS ops require a data buffer and that buffer must be < 4G. * Rather than having a memory allocator, just use this buffer * (get the lock first), make the RTAS call. Copy the data instead diff -Nru a/include/asm-ppc64/sigcontext.h b/include/asm-ppc64/sigcontext.h --- a/include/asm-ppc64/sigcontext.h Fri Jun 13 00:37:27 2003 +++ b/include/asm-ppc64/sigcontext.h Fri Jun 13 00:37:27 2003 @@ -9,8 +9,6 @@ */ #include -#include - struct sigcontext { unsigned long _unused[4]; @@ -18,9 +16,7 @@ int _pad0; unsigned long handler; unsigned long oldmask; - struct pt_regs *regs; - elf_gregset_t gp_regs; - elf_fpregset_t fp_regs; + struct pt_regs *regs; }; #endif /* _ASM_PPC64_SIGCONTEXT_H */ diff -Nru a/include/asm-ppc64/topology.h b/include/asm-ppc64/topology.h --- a/include/asm-ppc64/topology.h Fri Jun 13 00:37:27 2003 +++ b/include/asm-ppc64/topology.h Fri Jun 13 00:37:27 2003 @@ -20,23 +20,32 @@ return node; } -#define memblk_to_node(memblk) (memblk) +static inline int node_to_first_cpu(int node) +{ + int cpu; -#define parent_node(node) (node) + for(cpu = 0; cpu < NR_CPUS; cpu++) + if (numa_cpu_lookup_table[cpu] == node) + return cpu; -static inline unsigned long node_to_cpumask(int node) -{ - return numa_cpumask_lookup_table[node]; + BUG(); /* couldn't find a cpu on given node */ + return -1; } -static inline int node_to_first_cpu(int node) +static inline unsigned long node_to_cpumask(int node) { - return __ffs(node_to_cpumask(node)); -} + int cpu; + unsigned long mask = 0UL; -#define node_to_memblk(node) (node) + if (sizeof(unsigned long) * 8 < NR_CPUS) + BUG(); -#define pcibus_to_cpumask(bus) (cpu_online_map) + for(cpu = 0; cpu < NR_CPUS; cpu++) + if (numa_cpu_lookup_table[cpu] == node) + mask |= 1UL << cpu; + + return mask; +} /* Cross-node load balancing interval. */ #define NODE_BALANCE_RATE 10 diff -Nru a/include/asm-ppc64/types.h b/include/asm-ppc64/types.h --- a/include/asm-ppc64/types.h Fri Jun 13 00:37:27 2003 +++ b/include/asm-ppc64/types.h Fri Jun 13 00:37:27 2003 @@ -66,11 +66,6 @@ typedef u32 dma_addr_t; typedef u64 dma64_addr_t; -typedef struct { - unsigned long entry; - unsigned long toc; - unsigned long env; -} func_descr_t; #endif /* __ASSEMBLY__ */ #endif /* __KERNEL__ */ diff -Nru a/include/asm-ppc64/ucontext.h b/include/asm-ppc64/ucontext.h --- a/include/asm-ppc64/ucontext.h Fri Jun 13 00:37:27 2003 +++ b/include/asm-ppc64/ucontext.h Fri Jun 13 00:37:27 2003 @@ -1,9 +1,8 @@ #ifndef _ASMPPC64_UCONTEXT_H #define _ASMPPC64_UCONTEXT_H -#include - -/* +/* Copied from i386. + * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public License * as published by the Free Software Foundation; either version @@ -14,9 +13,8 @@ unsigned long uc_flags; struct ucontext *uc_link; stack_t uc_stack; - sigset_t uc_sigmask; - sigset_t __unsued[15]; /* Allow for uc_sigmask growth */ - struct sigcontext uc_mcontext; /* last for extensibility */ + struct sigcontext uc_mcontext; + sigset_t uc_sigmask; /* mask last for extensibility */ }; #endif /* _ASMPPC64_UCONTEXT_H */ diff -Nru a/include/asm-ppc64/unistd.h b/include/asm-ppc64/unistd.h --- a/include/asm-ppc64/unistd.h Fri Jun 13 00:37:27 2003 +++ b/include/asm-ppc64/unistd.h Fri Jun 13 00:37:27 2003 @@ -260,7 +260,7 @@ #define __NR_clock_getres 247 #define __NR_clock_nanosleep 248 -#define __NR_syscalls 239 +#define __NR_syscalls 249 #ifdef __KERNEL__ #define NR_syscalls __NR_syscalls #endif diff -Nru a/include/asm-ppc64/xics.h b/include/asm-ppc64/xics.h --- a/include/asm-ppc64/xics.h Fri Jun 13 00:37:27 2003 +++ b/include/asm-ppc64/xics.h Fri Jun 13 00:37:27 2003 @@ -12,17 +12,7 @@ #ifndef _PPC64_KERNEL_XICS_H #define _PPC64_KERNEL_XICS_H -#include - void xics_init_IRQ(void); int xics_get_irq(struct pt_regs *); -void xics_setup_cpu(void); -void xics_cause_IPI(int cpu); - -struct xics_ipi_struct { - volatile unsigned long value; -} ____cacheline_aligned; - -extern struct xics_ipi_struct xics_ipi_message[NR_CPUS] __cacheline_aligned; #endif /* _PPC64_KERNEL_XICS_H */